// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@

//
#include "process.h"
#include "CConnect.h"
#include "tdm_odbcDrvMsg.h"
#include "DrvrNet.h"
#include "nlsFunctions.h"
#include "resource.h"
#include "CStmt.h"
#include "security.h"
#include "DiagFunctions.h"
#include "drvrnet.h"
#include "csconvert.h"
#include <psapi.h>

#define UNKNOWN_WINDOW		"UNKNOWN"

int getCLCurrentUserDesc(char* usersid,char* username,char* domain)
{
	return 0;
}

// Implements the member functions of CConnect

CConnect::CConnect(SQLHANDLE InputHandle) : CHandle(SQL_HANDLE_DBC, InputHandle)
{
	m_TranslateLibHandle = NULL;
	m_SecPwd = NULL;

	reset();
	m_ConnectEvent = NULL;
	m_EnvHandle = (CEnv *)InputHandle;

	m_asTCPIPSystem = GTransport.m_TCPIPSystemDrvr_list->ins_node();
	m_srvrTCPIPSystem = GTransport.m_TCPIPSystemDrvr_list->ins_node();
	InitializeCriticalSection(&m_CSTransmision);
	m_IgnoreCancel = false; 
	m_StartNode = -1;
}

CConnect::~CConnect()
{
	if (m_ConnectEvent != NULL)
		CloseHandle(m_ConnectEvent);
	if (m_asTCPIPSystem != NULL)
		GTransport.m_TCPIPSystemDrvr_list->del_node(m_asTCPIPSystem);
	if (m_srvrTCPIPSystem != NULL)
		GTransport.m_TCPIPSystemDrvr_list->del_node(m_srvrTCPIPSystem);
	DeleteCriticalSection(&m_CSTransmision);
	
	if (m_SecPwd != NULL)
		delete m_SecPwd;
}

SQLRETURN CConnect::initialize()
{
	if (m_ConnectEvent == NULL) 
	{
		m_ConnectEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
		if (m_ConnectEvent == NULL)
		{
			setNTError(getErrorMsgLang(), "initialize - CreateEvent()");
			return SQL_ERROR;
		}
	}
	return SQL_SUCCESS;
}


void CConnect::reset(bool clError)
{

	if(clError)
		clearError();
	m_HeartBeatEnable = TRUE;
		
	m_RetSQLSvc_ObjRef[0] = '\0';
	m_ASSvc_ObjRef[0] = '\0';
	m_SQLSvc_ObjRef[0] = '\0';
	m_DialogueId = -1;
	m_SrvrDSName[0] ='\0';
	m_SrvrDSReadType = 0;
	m_SrvrIdentity[0] = '\0';
	
	m_AccessMode = SQL_MODE_DEFAULT;
	m_AutoIPD = SQL_TRUE;			// Automatic population of IPD is supported
	m_AutoCommit = SQL_AUTOCOMMIT_DEFAULT;
	m_ConnectionTimeout = DRVR_PENDING;
	m_CurrentCatalog[0] = '\0';
	m_CurrentSchema[0] = '\0'; 
	m_LoginTimeout	= DRVR_PENDING;
	m_ODBCCursors = SQL_CUR_USE_DRIVER;
	m_PacketSize = 0;	// Not Used
	m_QuietMode = NULL;
	m_Trace = SQL_OPT_TRACE_OFF;
	m_TraceFile[0] = '\0';
	m_TranslateLib[0] = '\0';
	m_TranslateOption = DRVR_PENDING;
	m_TxnIsolation = gDrvrGlobal.gDefaultTxnIsolation;
	m_ConnectionDead = SQL_CD_TRUE;
	m_CDInfoSent	= TRUE;

	m_AsyncEnable = SQL_ASYNC_ENABLE_DEFAULT;
	m_MetadataId = SQL_FALSE;		// Catalog functions arguments are not treated as identifiers
	
	m_Concurrency = SQL_CONCUR_DEFAULT;
	m_CursorType = SQL_CURSOR_TYPE_DEFAULT;
	m_MaxLength = SQL_MAX_LENGTH_DEFAULT;
	m_MaxRows = SQL_MAX_ROWS_DEFAULT;
	m_Noscan = SQL_NOSCAN_DEFAULT;
	m_QueryTimeout = SQL_QUERY_TIMEOUT_DEFAULT;
	m_SimulateCursor = SQL_SC_NON_UNIQUE;
	m_UseBookmarks = SQL_UB_DEFAULT;
	if (m_TranslateLibHandle)
	{
		FreeLibrary(m_TranslateLibHandle);
		m_TranslateLibHandle = NULL;
	}
	m_FPSQLDriverToDataSource = NULL;
	m_FPSQLDataSourceToDriver = NULL;

	m_RowsetErrorRecovery = 0;

	m_FetchBufferSize = 0;
	m_ChangePassword = FALSE;

	strcpy(m_QSServiceName,HP_DEFAULT_SERVICE);

	//wms_mapping
	memset(m_QueryID_SessionName, 0, sizeof(m_QueryID_SessionName));
	memset(m_applName, 0, sizeof(m_applName));
	
	m_IgnoreCancel = false;
	m_FetchAhead = 0;
	m_UserRole[0] = '\0';

	m_CertificateDir[0] = '\0';
	m_CertificateFile[0] = '\0';
	m_CertificateFileActive[0] = '\0';

	m_SecurityMode = 1; // security mode should be 1 by default
	m_RetryEncryption = false;
	memset(&m_SecInfo, 0, sizeof(m_SecInfo));

	if (m_SecPwd != NULL)
	{
		delete m_SecPwd;
		m_SecPwd = NULL;
	}
	m_StartNode = -1;
}

void CConnect::setVersion(const VERSION_LIST_def *versionList,int componentId)
{
	unsigned long i;
	VERSION_def		*version;

	for ( i = 0; i < versionList->_length ; i++)
	{
		version = versionList->_buffer + i;
		if ((version->componentId) == NT_ODBCAS_COMPONENT || version->componentId == NSK_ODBCAS_COMPONENT) // NT or NSK
		{
			m_ASVersion.componentId = version->componentId;
			m_ASVersion.majorVersion = version->majorVersion;
			m_ASVersion.minorVersion = version->minorVersion;
			m_ASVersion.buildId = version->buildId;
		}
		if ((version->componentId & 0x00FF) == ODBC_SRVR_COMPONENT) //odbcSrvr
		{
			m_SrvrVersion.componentId = version->componentId;
			m_SrvrVersion.majorVersion = version->majorVersion;
			m_SrvrVersion.minorVersion = version->minorVersion;
			m_SrvrVersion.buildId = version->buildId;

            if((componentId == ODBC_SRVR_COMPONENT) && 
				version->buildId & MXO_SPECIAL_1_MODE)
			{
		      gDrvrGlobal.gSpecial_1 = true;
			}
		}
		if ((version->componentId) == SQL_COMPONENT) // sql
		{
			m_SqlVersion.componentId = version->componentId;
			m_SqlVersion.majorVersion = version->majorVersion;
			m_SqlVersion.minorVersion = version->minorVersion;
			m_SqlVersion.buildId = version->buildId;
			m_SQLRowsetSupported = m_SqlVersion.minorVersion;
		}

	}
}

void CConnect::getVersion(VERSION_def *version, int componentId)
{
	if (componentId == NT_ODBCAS_COMPONENT || componentId == NSK_ODBCAS_COMPONENT) // NT or NSK
	{
		version->componentId = m_ASVersion.componentId;
		version->majorVersion = m_ASVersion.majorVersion;
		version->minorVersion = m_ASVersion.minorVersion;
		version->buildId = m_ASVersion.buildId;
	}
	else if (componentId == ODBC_SRVR_COMPONENT) //odbcSrvr
	{
		version->componentId = m_SrvrVersion.componentId;
		version->majorVersion = m_SrvrVersion.majorVersion;
		version->minorVersion = m_SrvrVersion.minorVersion;
		version->buildId = m_SrvrVersion.buildId;
	}
	else if (componentId == SQL_COMPONENT) // sql
	{
		version->componentId = m_SqlVersion.componentId;
		version->majorVersion = m_SqlVersion.majorVersion;
		version->minorVersion = m_SqlVersion.minorVersion;
		version->buildId = m_SqlVersion.buildId;
	}
	else
	{
		version->componentId = 0;
		version->majorVersion = 0;
		version->minorVersion = 0;
		version->buildId = 0;
	}
}

void CConnect::setOutContext(const OUT_CONNECTION_CONTEXT_def *outContext)
{
	setVersion(&outContext->versionList,ODBC_SRVR_COMPONENT);
	// if available, otherwise we'll stick with cpu,pin.
	IDL_OBJECT_def tmpStr;
	char *pToken = NULL;

	strcpy (tmpStr, m_RetSQLSvc_ObjRef);
	pToken = strtok (tmpStr, "$");
	if( pToken != NULL )
		pToken = strtok (NULL, ",");

	if( pToken != NULL ) {
		sprintf (m_SrvrIdentity, "%s($%s){%s}", 
				outContext->computerName,
				pToken,
				m_SQLSvc_ObjRef);
	}
	else
		sprintf (m_SrvrIdentity, "%s(%d,%d){%s}", 
				outContext->computerName,
				outContext->nodeId,
				outContext->processId,
				m_SQLSvc_ObjRef);

	if(outContext->outContextOptions1 & OUTCONTEXT_OPT1_IGNORE_SQLCANCEL)
		m_IgnoreCancel = true;

	strcpy(m_CurrentCatalog, (char*)outContext->catalog);
	strcpy(m_DSValue.m_DSSchema, (char*)outContext->schema);
	strcpy(m_CurrentSchema,m_DSValue.m_DSSchema); 
	

	if (outContext->outContextOptions1 & OUTCONTEXT_OPT1_ROLENAME) // outContext->outContextOptionString = "RN=<ROLE_NAME>;"
	{
		if(outContext->outContextOptionStringLen > 0)
		{
			pToken = strstr(outContext->outContextOptionString, "RN=");
			if (pToken != NULL)
				strcpy(m_UserRole, strtok(pToken+3,";"));
		}
	}

	if (IsTraceLibrary())
	{
		InitializeTrace();
		if (pdwGlobalTraceVariable && *pdwGlobalTraceVariable)
			LogInfo(&m_ASVersion,&m_SrvrVersion,&m_SqlVersion);
	}
}
		
void CConnect::setGetObjRefHdlOutput(const IDL_char *srvrObjRef,
		DIALOGUE_ID_def dialogueId,
		const IDL_char *dataSource, 
		const USER_SID_def *userSid,
		const VERSION_LIST_def *versionList,
		const IDL_long srvrNodeId,
		const IDL_long srvrProcessId,
		const IDL_long_long timestamp)
{
	strcpy(m_SQLSvc_ObjRef, srvrObjRef);
	m_DialogueId = dialogueId;
	strcpy(m_SrvrDSName, dataSource);
	m_SrvrDSReadType = 1;
	if (userSid->_length > 0)
		strcpyUTF8(m_UserSid, (const char *)userSid->_buffer, sizeof(m_UserSid), userSid->_length);
	else
		m_UserSid[0] = '\0';
	setVersion(versionList,NSK_ODBCAS_COMPONENT);
	if (srvrNodeId >= 0) 
	{
		m_SecInfo.cpu = srvrNodeId;
		m_SecInfo.pin = srvrProcessId;
		m_SecInfo.timestamp = timestamp;  
		m_SecurityMode = 1;
	}
	else
		m_SecurityMode = 0;
}

void CConnect::resetGetObjRefHdlOutput()
{
	memset(m_SQLSvc_ObjRef, 0, sizeof(m_SQLSvc_ObjRef));
	m_DialogueId = -1;
	memset(m_SrvrDSName, 0, sizeof(m_SrvrDSName));
	m_SrvrDSReadType = 0;
	m_UserSid[0] = '\0';
}
		
typedef int (WINAPI* GetDomainUser)( LPSTR , LPSTR );

BOOL CConnect::getUserDesc(char *userNameNTS, char *AuthenticationNTS, USER_DESC_def *userDesc)
{

	HINSTANCE		hGetDomainUser;
	GetDomainUser	pGetDomainUser;
	DWORD			dwError;
	int				rc;

 
	if (userNameNTS[0] == '\0') 
	{
		if( gDrvrGlobal.gPlatformId == VER_PLATFORM_WIN32_WINDOWS )
		{
// Windows95 when gMinorVersion = 0
// Windows98 when gMinorVersion = 1
			if( (hGetDomainUser = LoadLibrary("Win95DLL.DLL")) == NULL )
			{
				setNTError(getErrorMsgLang(), "getUserDesc - LoadLibrary()");
				return FALSE;
			}

			if ((pGetDomainUser = (GetDomainUser)GetProcAddress( hGetDomainUser, "GetDomainUser")) == (GetDomainUser)NULL)
			{
				setNTError(getErrorMsgLang(), "getUserDesc - GetProcAddress()");
				return FALSE;
			}

			m_UserDomain[0] = '\0';
			m_UserName[0] = '\0';
			rc = (pGetDomainUser)( m_UserDomain, m_UserName );

			FreeLibrary( hGetDomainUser );

			if	(! rc)
			{
				setDiagRec(DRIVER_ERROR, IDS_28_000, 0L, NULL);
				return FALSE;
			}
			else if (m_UserDomain[0] == '\0'|| strcmp(m_UserDomain, gDrvrGlobal.gComputerName) == 0 )			
			{
				setDiagRec(DRIVER_ERROR, IDS_28_000);
				return FALSE;
			}

			userDesc->userDescType = WIN95_USER_TYPE;
			userDesc->userName = m_UserName;
			userDesc->domainName = m_UserDomain;
			userDesc->userSid._length = 0;
			userDesc->userSid._buffer = NULL;
			userDesc->password._length = 0;
			userDesc->password._buffer = NULL;
		}
		else
		{
// Windows NT
			if ((dwError = getCLCurrentUserDesc(m_UserSid, m_UserName, m_UserDomain)) != 0)
			{
				setNTError(getErrorMsgLang(), "getUserDesc - getCLCurrentUserDesc()");
				return FALSE;
			}

			userDesc->userDescType = SID_TYPE;
			userDesc->userSid._length = strlen(m_UserSid);
			userDesc->userSid._buffer = (IDL_octet *)m_UserSid;
			userDesc->userName = m_UserName;
			userDesc->domainName = m_UserDomain;
			userDesc->password._length = 0;
			userDesc->password._buffer = NULL;
		}
	}
	else
	{
		strcpy(m_UserName, userNameNTS);
		m_UserDomain[0] = '\0';

		userDesc->userDescType = UNAUTHENTICATED_USER_TYPE;
		userDesc->userName = m_UserName;
		userDesc->domainName = m_UserDomain;
		userDesc->password._length = 0;
		userDesc->password._buffer = NULL;
		userDesc->userSid._length = 0;
		userDesc->userSid._buffer = NULL;

	}
	return TRUE;
}	

long CConnect::sendCDInfo(long exception_nr)
{
	long retcode = CEE_SUCCESS;
//	SRVR_CALL_CONTEXT	srvrCallContext;
	// populate the SrvrCallContext
	if (exception_nr == -27 || exception_nr == -29 || exception_nr == -39 || 
		exception_nr == COMM_LINK_FAIL_EXCEPTION)
	{
		m_ConnectionDead = SQL_CD_TRUE;
		if (! m_CDInfoSent)
		{
/*			
			srvrCallContext.sqlHandle = this;
			srvrCallContext.ASSvc_ObjRef = m_ASSvc_ObjRef;
			srvrCallContext.SQLSvc_ObjRef = m_SQLSvc_ObjRef;
			srvrCallContext.srvrState = SRVR_ABENDED;
			retcode = resetSrvrState(&srvrCallContext);
			retcode = sendStopServer();
*/
			reset();
		}
	}
	else
		retcode = exception_nr;
	return retcode;
}

long CConnect::sendStopServer()
{
	long retcode=CEE_SUCCESS;
	SRVR_CALL_CONTEXT	srvrCallContext;

	srvrCallContext.sqlHandle = this;
	srvrCallContext.ASSvc_ObjRef = m_ASSvc_ObjRef;
	srvrCallContext.SQLSvc_ObjRef = m_SQLSvc_ObjRef;
	srvrCallContext.dialogueId = m_DialogueId;
	retcode = stopSrvrAbrupt(&srvrCallContext);

	return retcode;
}

SQLRETURN CConnect::Connect(SQLCHAR *ServerName, 
		   SQLSMALLINT	NameLength1,
           SQLCHAR		*UserName, 
		   SQLSMALLINT	NameLength2,
           SQLCHAR		*Authentication, 
		   SQLSMALLINT	NameLength3,
		   BOOL			readDSN)
{
	short					retCode=SQL_SUCCESS;
	HWND					currentWindow;
	TCHAR					windowText[128];
	CONNECTION_CONTEXT_def	inContext;
	USER_DESC_def			userDesc;
	SQLRETURN				rc;
//	SQLRETURN				rc1,rc2;
	char					ServerNameNTS[MAX_SQL_IDENTIFIER_LEN+1];
	char					UserNameNTS[MAX_SQL_IDENTIFIER_LEN+1];
	//Arvind: Modified to hold password of <128 Chars,128 Chars,128 Chars with NULL>
	char					AuthenticationNTS[3*MAX_SQL_IDENTIFIER_LEN+3];
	VERSION_def version[2];
	VERSION_def* versionPtr = &version[0];
	DWORD					clientUserNameLen=0;
	
	char computerNameUTF8[MAX_COMPUTERNAME_LENGTH*4+1];
	char windowTextUTF8[MAX_SQL_IDENTIFIER_LEN+1];
	char clientUserNameUTF8[MAX_SQL_IDENTIFIER_LEN+1];
	int  translen=0;
	char transError[128];
	
	clearError();

	m_CurrentOdbcAPI = SQL_API_SQLCONNECT;

	if (NameLength1 == SQL_NTS)
		strcpyUTF8(ServerNameNTS, (const char *)ServerName, sizeof(ServerNameNTS));
	else
	if (NameLength1 < sizeof(ServerNameNTS))
		strcpyUTF8(ServerNameNTS, (const char *)ServerName, sizeof(ServerNameNTS), NameLength1);
	else
	{
		setDiagRec(DRIVER_ERROR, IDS_IM_010);
		return SQL_ERROR;
	}

	if (UserName != NULL)
	{
		if (NameLength2 == SQL_NTS)
			strcpyUTF8(UserNameNTS, (const char *)UserName,sizeof(UserNameNTS));
		else
		if (NameLength2 < sizeof(UserNameNTS))
			strcpyUTF8(UserNameNTS, (const char *)UserName, sizeof(UserNameNTS), NameLength2);
		else
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_090);
			return SQL_ERROR;
		}
	}
	else
		UserNameNTS[0] = '\0';

	if (Authentication != NULL)
	{
		if (NameLength3 == SQL_NTS)
			strcpyUTF8(AuthenticationNTS, (const char *)Authentication, sizeof(AuthenticationNTS));
		else
		if (NameLength3 < sizeof(AuthenticationNTS))
			strcpyUTF8(AuthenticationNTS, (const char *)Authentication, sizeof(AuthenticationNTS), NameLength3);
		else
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_090);
			return SQL_ERROR;
		}
	}
	else
		AuthenticationNTS[0] = '\0';
	
	if (readDSN)
	{
		transError[0] = '\0';
		// Read DS Values (DS can now be only System DSN or User DSN)
		retCode = m_DSValue.readDSValues(ServerNameNTS, transError);

		switch (retCode)
		{
		case ERROR_SUCCESS:
			break;
		case DS_AS_KEY_NOT_FOUND:
			setDiagRec(DRIVER_ERROR, IDS_08_001_01, GetLastError());
			return SQL_ERROR;
		case DS_NOT_FOUND:
			setDiagRec(DRIVER_ERROR, IDS_IM_002);
			return SQL_ERROR;
		case DS_TRANSLATION_ERROR:
			if(transError[0] == '\0')
				setDiagRec(DRIVER_ERROR, IDS_TRANSLATE_ERROR);
			else
				setDiagRec(DRIVER_ERROR, IDS_TRANSLATE_ERROR, 0, transError);
			return SQL_ERROR;
		default:
			setDiagRec(DRIVER_ERROR, IDS_HY_000, GetLastError());
			return SQL_ERROR;
		}
	}

	// Update the connection attributes from DSValues if it is not set already 
	if (m_CurrentCatalog[0] == '\0')
		strcpy(m_CurrentCatalog, m_DSValue.m_DSCatalog);
	if (m_CurrentSchema[0] == '\0') 
		strcpy(m_CurrentSchema, m_DSValue.m_DSSchema);
	if (m_ConnectionTimeout == DRVR_PENDING)
		m_ConnectionTimeout = m_DSValue.m_DSConnectionTimeout;
	if (m_LoginTimeout == DRVR_PENDING)
		m_LoginTimeout = m_DSValue.m_DSLoginTimeout;
	if (m_TranslateLib[0] == '\0')
		strcpy(m_TranslateLib, m_DSValue.m_DSTranslationDLL);
	if (m_TranslateOption == DRVR_PENDING)
		m_TranslateOption = m_DSValue.m_DSTranslationOption;
	m_QueryTimeout = m_DSValue.m_DSQueryTimeout;
	m_SelectRowsets = m_DSValue.m_DSSelectRowsets;

	m_IOCompression = m_DSValue.m_DSIOCompression;
	if (m_asTCPIPSystem != NULL)
		m_asTCPIPSystem->m_IOCompression = m_IOCompression;
	if (m_srvrTCPIPSystem != NULL)
		m_srvrTCPIPSystem->m_IOCompression = m_IOCompression;

	if (m_asTCPIPSystem != NULL)
		m_asTCPIPSystem->m_IOCompressionThreshold = m_DSValue.m_DSIOCompressionThreshold;
	if (m_srvrTCPIPSystem != NULL)
		m_srvrTCPIPSystem->m_IOCompressionThreshold = m_DSValue.m_DSIOCompressionThreshold;
	//if (m_DSValue.m_DSServiceName[0] != 0)
	///	strcpy(m_QSServiceName, m_DSValue.m_DSServiceName);
	
	// Set the Assocation Service Object Reference
	strcpy(m_ASSvc_ObjRef, m_DSValue.m_DSServer);
	strcat(m_ASSvc_ObjRef, ":NonStopODBCAS");

	m_RowsetErrorRecovery = m_DSValue.m_DSRowsetErrorRecovery;
	m_FetchBufferSize = m_DSValue.m_DSFetchBufferSize;
	m_FlushFetchData = m_DSValue.m_DSFlushFetchData;

	/*
	// Load the Translation DLL
	if (InitializeTranslation() != SQL_SUCCESS)
		return SQL_ERROR;
	*/

	// populate the inContext
	inContext.location[0] = '\0';
	inContext.userRole[0] = '\0';
    inContext.sessionName[0] = '\0';

	if (m_DSValue.m_DSServerDSName[0] != 0)
		strcpy(inContext.datasource, m_DSValue.m_DSServerDSName);
	else
		strcpy(inContext.datasource, m_DSValue.m_DSName);
	strcpy(inContext.catalog, m_CurrentCatalog);
	strcpy(inContext.schema, m_DSValue.m_DSSchema);

	inContext.accessMode = (IDL_short)m_AccessMode;
	inContext.autoCommit = (IDL_short)m_AutoCommit; 
	inContext.queryTimeoutSec = m_ConnectionTimeout;
	inContext.idleTimeoutSec = 0;
	inContext.loginTimeoutSec = m_LoginTimeout;
	inContext.txnIsolationLevel = (IDL_short)m_TxnIsolation;
	if (m_FetchBufferSize < 0)
		inContext.rowSetSize = 0;
	else
		inContext.rowSetSize = (short)(m_FetchBufferSize/1024);
	inContext.diagnosticFlag = 0;
	inContext.processId = gDrvrGlobal.gProcessId;

	if (TranslateUTF8(FALSE, gDrvrGlobal.gComputerName, strlen(gDrvrGlobal.gComputerName),
			      computerNameUTF8, sizeof(computerNameUTF8), &translen, transError) != SQL_SUCCESS)
	{
		setDiagRec(DRIVER_ERROR, IDS_HY_000, 0, "Translation Failed: gDrvrGlobal.gComputerName");
		return SQL_ERROR;
	}
	if (strlen(computerNameUTF8) > 0)
		strcpyUTF8(gDrvrGlobal.gComputerName, computerNameUTF8, sizeof(gDrvrGlobal.gComputerName));
	else
		strcpy(gDrvrGlobal.gComputerName, "UNKNOWN");
	strcpy(inContext.computerName, gDrvrGlobal.gComputerName);

	if (m_DSValue.m_DSServiceName[0] != 0)
		strcpy(m_QSServiceName, m_DSValue.m_DSServiceName);

	if ((currentWindow = GetActiveWindow()) != NULL)
	{
		if (GetWindowText(currentWindow, windowText, sizeof(windowText)) == 0)
		{
			if(GetModuleBaseName(GetCurrentProcess(), NULL, windowText,sizeof(windowText)) == 0)
#ifdef _WIN64
				strcpy(windowText,"WINDOWSODBC64");
#else
				strcpy(windowText,"WINDOWSODBC");
#endif
		}
	}
	else
	{
		if(GetModuleBaseName(GetCurrentProcess(), NULL, windowText,sizeof(windowText)) == 0)
#ifdef _WIN64
			strcpy(windowText,"WINDOWSODBC64");
#else
			strcpy(windowText,"WINDOWSODBC");
#endif
	}
	if (TranslateUTF8(FALSE, windowText, strlen(windowText), windowTextUTF8, sizeof(windowTextUTF8), &translen, transError) != SQL_SUCCESS)
	{
		setDiagRec(DRIVER_ERROR, IDS_HY_000, 0, "Translation Failed: windowText");
		return SQL_ERROR;
	}

	//wms_mapping
	if(m_applName[0] != '\0') 
	{
		inContext.inContextOptions2 |= MAPPING_APPL;
		inContext.windowText = m_applName; 
	}
	else if(m_DSValue.m_DSApplication[0] != '\0') 
	{
		inContext.inContextOptions2 |= MAPPING_APPL;
		inContext.windowText = m_DSValue.m_DSApplication; 
	}
	else
		inContext.windowText = windowTextUTF8;

	ODBCNLS_GetCodePage (&inContext.ctxACP);
	inContext.ctxDataLang = SQLCHARSETCODE_UTF8;
	inContext.ctxErrorLang = SQLCHARSETCODE_ISO88591;
	inContext.ctxCtrlInferNCHAR = -1;
	if(m_StartNode == -1)
		inContext.cpuToUse = -1;
	else
		inContext.cpuToUse = m_StartNode;
    inContext.connectOptions = NULL;
	inContext.inContextOptions1 = 0;
	inContext.inContextOptions2 = 0;

	//wms_mapping
	if(m_QueryID_SessionName[0] != '\0')
	{
		inContext.inContextOptions1 = inContext.inContextOptions1 | INCONTEXT_OPT1_SESSIONNAME;
		inContext.inContextOptions2 |= MAPPING_SESSION;
		strcpy(inContext.sessionName,m_QueryID_SessionName);
	}
	else if(m_DSValue.m_DSSession[0] != '\0') 
	{
		inContext.inContextOptions1 = inContext.inContextOptions1 | INCONTEXT_OPT1_SESSIONNAME;
		inContext.inContextOptions2 |= MAPPING_SESSION;
		strcpy(inContext.sessionName,m_DSValue.m_DSSession);
	}

	if(m_FetchAhead == 1)
		inContext.inContextOptions1 = inContext.inContextOptions1 | INCONTEXT_OPT1_FETCHAHEAD;

	if(strlen(m_UserRole) > 0)
	{
		strcpy(inContext.userRole,m_UserRole);
	}
	else if(m_DSValue.m_DSRoleName[0] != '\0')
	{
		strcpy(inContext.userRole,m_DSValue.m_DSRoleName);
	}

	// Set the version no of ODBC Driver
	inContext.clientVersionList._length = 2; 
	inContext.clientVersionList._buffer = versionPtr; 
	versionPtr->componentId = gDrvrGlobal.gClientVersion.componentId; 
	versionPtr->majorVersion = 3;
	versionPtr->minorVersion = 0;
	versionPtr->buildId = gDrvrGlobal.gClientVersion.buildId | ROWWISE_ROWSET | CHARSET | PASSWORD_SECURITY;
	versionPtr++;
	versionPtr->componentId = APP_COMPONENT; 
	versionPtr->majorVersion = (IDL_short)m_EnvHandle->getODBCAppVersion();
	versionPtr->minorVersion = 0;
    versionPtr->buildId = 0;
	memcpy(inContext.clientVproc,gDrvrGlobal.gClientVproc,sizeof(gDrvrGlobal.gClientVproc));

	// populate the userDesc
	if (! getUserDesc(UserNameNTS, AuthenticationNTS, &userDesc))
		return SQL_ERROR;

	// Get client user name.
	clientUserNameLen = sizeof(UserNameNTS);
	if (GetUserName(UserNameNTS, &clientUserNameLen))
	{
		if (TranslateUTF8(FALSE, UserNameNTS, strlen(UserNameNTS),
				      clientUserNameUTF8, sizeof(clientUserNameUTF8), &translen, transError) != SQL_SUCCESS)
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_000, 0, "Translation Failed: UserNameNTS");
			return SQL_ERROR;
		}
		inContext.clientUserName = clientUserNameUTF8;
		inContext.inContextOptions1 = inContext.inContextOptions1 | INCONTEXT_OPT1_CLIENT_USERNAME;
	}
	else
		inContext.clientUserName = NULL;


	m_ConnectionDead = SQL_CD_TRUE;
	m_CDInfoSent = TRUE;				// May need to investigate

	
	// populate the SrvrCallContext
	m_srvrCallContext.sqlHandle = this;
	m_srvrCallContext.ASSvc_ObjRef = m_ASSvc_ObjRef;
	m_srvrCallContext.eventHandle = m_ConnectEvent;
	m_srvrCallContext.u.connectParams.loginTimeout = m_LoginTimeout;
	m_srvrCallContext.u.connectParams.inContext = &inContext;
	m_srvrCallContext.u.connectParams.userDesc = &userDesc;
	m_srvrCallContext.maxRowsetSize=-1;

retryGetObjRef:

	m_srvrCallContext.odbcAPI = SQL_API_GETOBJREF;
	m_srvrCallContext.SQLSvc_ObjRef = NULL;
	
	rc = ThreadControlProc(&m_srvrCallContext);
	if (rc == SQL_ERROR)
		return rc;
	m_srvrCallContext.odbcAPI = SQL_API_SQLCONNECT;
	m_srvrCallContext.SQLSvc_ObjRef = m_SQLSvc_ObjRef;
	m_srvrCallContext.dialogueId = m_DialogueId;

	if (m_SecurityMode == 1) // for pwd security
	{
		// this is the new encryption method R2.5+
		DoEncryption(m_SecPwd,m_SecInfo,userDesc,AuthenticationNTS,inContext);
	}

	rc = ThreadControlProc(&m_srvrCallContext);
	if (m_RetryEncryption && m_SecurityMode == 1)
	{
		m_RetryEncryption = false;
		retCode = SQL_SUCCESS;
//reset userDesc.username, it would have cleared up in the prev DoEncryption()
		userDesc.userName = m_UserName;
		if(userDesc.password._buffer != NULL && m_SecurityMode == 1)
			delete[] userDesc.password._buffer;
		DoEncryption(m_SecPwd,m_SecInfo,userDesc,AuthenticationNTS,inContext);

		rc = ThreadControlProc(&m_srvrCallContext);
	}
	switch (rc)
	{
	case SQL_STILL_EXECUTING:
		goto retryGetObjRef;
		break;
	case SQL_SUCCESS:
	case SQL_SUCCESS_WITH_INFO:
		// Return SQL_SUCCESS_WITH_INFO if the datasource names are not same
		if (m_DSValue.m_DSServerDSName[0] != 0)
		{
			if (strcmp(m_DSValue.m_DSServerDSName, m_SrvrDSName) != 0)
			{
				setDiagRec(DRIVER_ERROR, IDS_01_000_01, 0, NULL, NULL, SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1, m_SrvrDSName);
				rc = SQL_SUCCESS_WITH_INFO;
			}
		}
		else
		if (strcmp(m_DSValue.m_DSName, m_SrvrDSName) != 0)
		{
			setDiagRec(DRIVER_ERROR, IDS_01_000_01, 0, NULL, NULL, SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1, m_SrvrDSName);
			rc = SQL_SUCCESS_WITH_INFO;
		}

		// update the ConnectionDead values
		m_ConnectionDead = SQL_CD_FALSE;
		m_CDInfoSent	= FALSE;

		break;
	default:
		break;
	}
	if (rc != SQL_ERROR)
	{	
		if (m_DSValue.m_DSServiceName[0] != 0)
		{
			rc = SetConnectAttr(SET_SERVICE_NAME, 0, m_QSServiceName, NULL);
		}   
	}

	if(userDesc.password._buffer  != NULL)
	{
		if(m_SecurityMode == 1)
			delete[] userDesc.password._buffer;
		userDesc.password._length = 0;
		userDesc.password._buffer = NULL;
	}
	return rc;
}


SQLRETURN CConnect::Disconnect()
{
	SQLRETURN rc = SQL_SUCCESS;
	CHANDLECOLLECT::iterator i;

	clearError();
// If SQLBrowseConnect returns SQL_NEED_DATA
	if ( m_CurrentOdbcAPI == SQL_API_SQLBROWSECONNECT)
	{
		m_CurrentOdbcAPI = SQL_API_SQLDISCONNECT;
	}
	else
	{
		m_CurrentOdbcAPI = SQL_API_SQLDISCONNECT;
		if (m_ConnectionDead == SQL_CD_TRUE)
		{
			setDiagRec(DRIVER_ERROR, IDS_08_S01);
			rc = SQL_SUCCESS_WITH_INFO;
		}
		else
		{
			for (i = m_StmtCollect.begin() ; i !=  m_StmtCollect.end() ; ++i)
			{
				CStmt* pStmt = ((CStmt *)(*i));
				if (pStmt->m_AsyncEnable == SQL_ASYNC_ENABLE_ON && pStmt->m_AsyncThread != NULL)
				{
					setDiagRec(DRIVER_ERROR, IDS_HY_010);
					return SQL_ERROR;
				}
			}

			m_srvrCallContext.odbcAPI = SQL_API_SQLDISCONNECT;
			m_srvrCallContext.sqlHandle = this;
			m_srvrCallContext.SQLSvc_ObjRef = m_SQLSvc_ObjRef;
			m_srvrCallContext.ASSvc_ObjRef = m_ASSvc_ObjRef;
			m_srvrCallContext.eventHandle = m_ConnectEvent;
			m_srvrCallContext.dialogueId = m_DialogueId;
			m_srvrCallContext.connectionTimeout = m_ConnectionTimeout;
			m_srvrCallContext.maxRowsetSize=-1;
			rc = ThreadControlProc(&m_srvrCallContext);
			if (rc == -25000)
				return SQL_ERROR;
			rc = SQL_SUCCESS;

			while ((i = m_StmtCollect.begin()) !=  m_StmtCollect.end())
				delete ((CStmt *)(*i));

			while ((i = m_DescCollect.begin()) !=  m_DescCollect.end())
				delete ((CDesc *)(*i));
		}
	}
	reset(rc == SQL_SUCCESS );
	m_ConnectionDead = SQL_CD_TRUE;
	m_CDInfoSent = TRUE;

	m_asTCPIPSystem->resetSwap();
	m_srvrTCPIPSystem->resetSwap();

	return rc;
}

INT_PTR CALLBACK ConnectDialogProc(
  HWND hwndDlg,  // handle to dialog box
  UINT uMsg,     // message
  WPARAM wParam, // first message parameter
  LPARAM lParam  // second message parameter
)
{
	CONNECT_FIELD_ITEMS		*connectFieldItems;
	BOOL					retCode;
	HWND					hwndOwner; 
	RECT					rc, rcDlg, rcOwner; 
 
	switch (uMsg)
	{
	case WM_INITDIALOG:
		connectFieldItems = (CONNECT_FIELD_ITEMS *)lParam;
		SetWindowLongPtr(hwndDlg,GWLP_USERDATA,(LONG_PTR)connectFieldItems);
	    retCode = SetDlgItemText(hwndDlg, IDC_LOGIN_ID, connectFieldItems->loginId);
  		retCode = SetDlgItemText(hwndDlg, IDC_PASSWORD, connectFieldItems->password);
  		retCode = SetDlgItemText(hwndDlg, IDC_CATALOG, connectFieldItems->catalog);
  		retCode = SetDlgItemText(hwndDlg, IDC_SCHEMA, connectFieldItems->schema);
		// Set the Dialog Window Pos
		// Get the owner window and dialog box rectangles. 
// 	    if ((hwndOwner = GetParent(hwndDlg)) == NULL) 
//      {
            hwndOwner = GetDesktopWindow(); 
//      }

        GetWindowRect(hwndOwner, &rcOwner); 
        GetWindowRect(hwndDlg, &rcDlg); 
        CopyRect(&rc, &rcOwner); 
 
         // Offset the owner and dialog box rectangles so that 
         // right and bottom values represent the width and 
         // height, and then offset the owner again to discard 
         // space taken up by the dialog box. 
 
        OffsetRect(&rcDlg, -rcDlg.left, -rcDlg.top); 
        OffsetRect(&rc, -rc.left, -rc.top); 
        OffsetRect(&rc, -rcDlg.right, -rcDlg.bottom); 
 
         // The new position is the sum of half the remaining 
         // space and the owner's original position. 
 
        SetWindowPos(hwndDlg, 
            HWND_TOP, 
            rcOwner.left + (rc.right / 2), 
            rcOwner.top + (rc.bottom / 2), 
            0, 0,          // ignores size arguments 
            SWP_NOSIZE); 
 
        if (GetDlgCtrlID((HWND) wParam) != IDC_LOGIN_ID) 
        { 
            SetFocus(GetDlgItem(hwndDlg, IDC_LOGIN_ID)); 
            return FALSE; 
        } 
  		return TRUE;
	case WM_COMMAND:
		connectFieldItems = (CONNECT_FIELD_ITEMS*)GetWindowLongPtr(hwndDlg,GWLP_USERDATA);
		switch (LOWORD(wParam))
		{
		case IDOK:
			if (!GetDlgItemText(hwndDlg, IDC_LOGIN_ID, connectFieldItems->loginId,
						sizeof(connectFieldItems->loginId)))
					connectFieldItems->loginId[0] = '\0';
            if (!GetDlgItemText(hwndDlg, IDC_PASSWORD, connectFieldItems->password,
						sizeof(connectFieldItems->password)))
					connectFieldItems->password[0] = '\0';
//            if (!GetDlgItemText(hwndDlg, IDC_CATALOG, connectFieldItems->catalog,
//						sizeof(connectFieldItems->catalog)))
//					connectFieldItems->catalog[0] = '\0';
            if (!GetDlgItemText(hwndDlg, IDC_SCHEMA, connectFieldItems->schema,
						sizeof(connectFieldItems->schema)))
					connectFieldItems->schema[0] = '\0';            
			EndDialog(hwndDlg, TRUE);
			break;
		case IDCANCEL:
			EndDialog(hwndDlg, FALSE);
			break;
		}
		return TRUE;
	default:
		return FALSE;
	}
}

INT_PTR CALLBACK ConnectDriverKWDialogProc(
  HWND hwndDlg,  // handle to dialog box
  UINT uMsg,     // message
  WPARAM wParam, // first message parameter
  LPARAM lParam  // second message parameter
)
{
	CONNECT_FIELD_ITEMS		*connectFieldItems;
	BOOL					retCode;
	HWND					hwndOwner; 
	RECT					rc, rcDlg, rcOwner; 
 
	switch (uMsg)
	{
	case WM_INITDIALOG:
		connectFieldItems = (CONNECT_FIELD_ITEMS*)GetWindowLongPtr(hwndDlg,DWLP_USER);
		if(connectFieldItems==NULL)
			return FALSE;
	    retCode = SetDlgItemText(hwndDlg, IDC_DKW_SERVER, connectFieldItems->server);
  		retCode = SetDlgItemText(hwndDlg, IDC_DKW_LOGIN_ID, connectFieldItems->loginId);
  		retCode = SetDlgItemText(hwndDlg, IDC_DKW_PASSWORD, connectFieldItems->password);
  		retCode = SetDlgItemText(hwndDlg, IDC_DKW_CATALOG, connectFieldItems->catalog);
  		retCode = SetDlgItemText(hwndDlg, IDC_DKW_SCHEMA, connectFieldItems->schema);
		// Set the Dialog Window Pos  
		// Get the owner window and dialog box rectangles. 
 	    if ((hwndOwner = GetParent(hwndDlg)) == NULL) 
	    {
            hwndOwner = GetDesktopWindow(); 
		}

        GetWindowRect(hwndOwner, &rcOwner); 
        GetWindowRect(hwndDlg, &rcDlg); 
        CopyRect(&rc, &rcOwner); 
 
         // Offset the owner and dialog box rectangles so that 
         // right and bottom values represent the width and 
         // height, and then offset the owner again to discard 
         // space taken up by the dialog box. 
 
        OffsetRect(&rcDlg, -rcDlg.left, -rcDlg.top); 
        OffsetRect(&rc, -rc.left, -rc.top); 
        OffsetRect(&rc, -rcDlg.right, -rcDlg.bottom); 
 
         // The new position is the sum of half the remaining 
         // space and the owner's original position. 
 
        SetWindowPos(hwndDlg, 
            HWND_TOP, 
            rcOwner.left + (rc.right / 2), 
            rcOwner.top + (rc.bottom / 2), 
            0, 0,          // ignores size arguments 
            SWP_NOSIZE); 
 
        if (GetDlgCtrlID((HWND) wParam) != IDC_DKW_SERVER) 
        { 
            SetFocus(GetDlgItem(hwndDlg, IDC_DKW_SERVER)); 
            return FALSE; 
        } 
  		return TRUE;
	case WM_COMMAND:
		connectFieldItems = (CONNECT_FIELD_ITEMS*)GetWindowLongPtr(hwndDlg,DWLP_USER);
		if(connectFieldItems==NULL)
			return FALSE;
		switch (LOWORD(wParam))
		{
		case IDOK:
			if (!GetDlgItemText(hwndDlg, IDC_DKW_SERVER, connectFieldItems->server,
						sizeof(connectFieldItems->server)))
					connectFieldItems->server[0] = '\0';
            if (!GetDlgItemText(hwndDlg, IDC_DKW_LOGIN_ID, connectFieldItems->loginId,
						sizeof(connectFieldItems->loginId)))
					connectFieldItems->loginId[0] = '\0';
            if (!GetDlgItemText(hwndDlg, IDC_DKW_PASSWORD, connectFieldItems->password,
						sizeof(connectFieldItems->password)))
					connectFieldItems->password[0] = '\0';
//            if (!GetDlgItemText(hwndDlg, IDC_DKW_CATALOG, connectFieldItems->catalog,
//						sizeof(connectFieldItems->catalog)))
//					connectFieldItems->catalog[0] = '\0';
            if (!GetDlgItemText(hwndDlg, IDC_DKW_SCHEMA, connectFieldItems->schema,
						sizeof(connectFieldItems->schema)))
					connectFieldItems->schema[0] = '\0';
			if (connectFieldItems->server[0] == '\0'){
				MessageBox(hwndDlg, MSG_SERVERID_EMPTY, ODBCMX_ERROR_MSGBOX_TITLE, MB_OK | MB_ICONEXCLAMATION );
				SetFocus(GetDlgItem(hwndDlg, IDC_DKW_SERVER)); 
            }
			PostMessage(hwndDlg,WM_QUIT,0,0);
			break;
		case IDCANCEL:
			PostMessage(hwndDlg,WM_QUIT,1,0);
			break;
		}
		return TRUE;
	default:
		return FALSE;
	}
}

/****************************************************************************
*  Added by RAJANI
*  Function Name	: ChangePwdProc
*  Arguments		: 1-> handle to dialog box
*  			  2-> message
*  			  3-> first message parameter
*  			  4-> second message parameter
*  Purpose		: Function to populate the dialog box for 
*  			  receving the inputs from the user for 
*  			  changing the password
******************************************************************************/
INT_PTR CALLBACK ChangePwdProc(
			HWND hwndDlg,  // handle to dialog box
			UINT uMsg,     // message
			WPARAM wParam, // first message parameter
			LPARAM lParam  // second message parameter
			)
{
	CONNECT_FIELD_ITEMS		*connectFieldItems;
	BOOL					retCode;
	HWND					hwndOwner; 
	RECT					rc, rcDlg, rcOwner;
	char	newpassword[MAX_SQL_IDENTIFIER_LEN+1];
	char	verifypwd[MAX_SQL_IDENTIFIER_LEN+1];
	switch (uMsg)
	{
	case WM_INITDIALOG:
		connectFieldItems = (CONNECT_FIELD_ITEMS *)lParam;
		SetWindowLongPtr(hwndDlg,GWLP_USERDATA,(LONG_PTR)connectFieldItems);
  		retCode = SetDlgItemText(hwndDlg, IDC_USERNAME, connectFieldItems->loginId);
		hwndOwner = GetDesktopWindow(); 

        GetWindowRect(hwndOwner, &rcOwner); 
        GetWindowRect(hwndDlg, &rcDlg); 
        CopyRect(&rc, &rcOwner); 
 
         // Offset the owner and dialog box rectangles so that 
         // right and bottom values represent the width and 
         // height, and then offset the owner again to discard 
         // space taken up by the dialog box. 
 
		OffsetRect(&rcDlg, -rcDlg.left, -rcDlg.top); 
		OffsetRect(&rc, -rc.left, -rc.top); 
		OffsetRect(&rc, -rcDlg.right, -rcDlg.bottom); 
 
		// The new position is the sum of half the remaining 
		// space and the owner's original position. 
 
		SetWindowPos(hwndDlg, HWND_TOP, rcOwner.left + (rc.right / 2),
			rcOwner.top + (rc.bottom / 2), 
            0, 0,          // ignores size arguments 
            SWP_NOSIZE); 
  		return TRUE;
	case WM_COMMAND:
		connectFieldItems = (CONNECT_FIELD_ITEMS*)GetWindowLongPtr(hwndDlg,GWLP_USERDATA);
		switch (LOWORD(wParam))
		{
		case IDOK:
			if (!GetDlgItemText(hwndDlg, IDC_USERNAME, connectFieldItems->loginId,
						sizeof(connectFieldItems->loginId)))
			{	
					connectFieldItems->loginId[0] = '\0';
					MessageBox(hwndDlg, MSG_USERNAME_EMPTY, ODBCMX_ERROR_MSGBOX_TITLE, MB_OK | MB_ICONEXCLAMATION );
					SetFocus(GetDlgItem(hwndDlg, IDC_USERNAME));
					break;
			}
            if (!GetDlgItemText(hwndDlg, IDC_OLD_PWD, connectFieldItems->password,
						sizeof(connectFieldItems->password)))
			{
					connectFieldItems->password[0] = '\0';
					MessageBox(hwndDlg, MSG_OLDPASSWORD_EMPTY, ODBCMX_ERROR_MSGBOX_TITLE, MB_OK | MB_ICONEXCLAMATION );
					SetFocus(GetDlgItem(hwndDlg, IDC_OLD_PWD));
					break;
			}
			if (!GetDlgItemText(hwndDlg, IDC_NEW_PWD, newpassword,
						sizeof(newpassword)))
			{
					newpassword[0] = '\0';
					MessageBox(hwndDlg, MSG_NEWPASSWORD_EMPTY, ODBCMX_ERROR_MSGBOX_TITLE, MB_OK | MB_ICONEXCLAMATION );
					SetFocus(GetDlgItem(hwndDlg, IDC_NEW_PWD));
					break;
			}
			if (!GetDlgItemText(hwndDlg, IDC_VERIFY_PWD, verifypwd,
						sizeof(verifypwd)))
			{
					verifypwd[0] = '\0';
					MessageBox(hwndDlg, MSG_VERIFYPASSWORD_EMPTY, ODBCMX_ERROR_MSGBOX_TITLE, MB_OK | MB_ICONEXCLAMATION );
					SetFocus(GetDlgItem(hwndDlg, IDC_VERIFY_PWD));
					break;
			}
			else if ( strcmp(newpassword,verifypwd) != 0)  
			{
				    MessageBox(hwndDlg, MSG_VERIFYPASSWORD_EQUAL, ODBCMX_ERROR_MSGBOX_TITLE, MB_OK | MB_ICONEXCLAMATION );
					SetFocus(GetDlgItem(hwndDlg, IDC_NEW_PWD));
					newpassword[0]='\0';
					verifypwd[0]='\0';
					break;
			}
			if ( strlen(newpassword)!= 0 && strlen(verifypwd)!= 0 )
			{
					sprintf(connectFieldItems->password,"%s,%s,%s",connectFieldItems->password,newpassword,verifypwd);
					EndDialog(hwndDlg, TRUE);
			}
			break;
		case IDCANCEL:
			EndDialog(hwndDlg, FALSE);
			break;
		}
		return TRUE;
	default:
		return FALSE;
	}
}

SQLRETURN CConnect::generateConnectionString(CONNECT_KEYWORD_TREE *KeywordTree, 
				CONNECT_FIELD_ITEMS	*ConnectFieldItems,
				short				DSNAttrNo, 
				SQLCHAR				*OutConnectionString,
				SQLSMALLINT			BufferLength,
				SQLSMALLINT 		*StringLength2Ptr)
{
	SQLRETURN		rc = SQL_SUCCESS;
	char			tempBuffer[1029];
	char			*equalString = "=";
	char			*colonString = ";";
	SQLSMALLINT		strLen;
	SQLSMALLINT		lengthCopied;
	SQLSMALLINT		totalLength;
	short			i;

	tempBuffer[0] = 0;
	// Write DSN or DRIVER name
	if (DSNAttrNo < KEY_MAX)
	{
		strcpy(tempBuffer, ConnectKeywords[DSNAttrNo]);
		strcat(tempBuffer, equalString);
		strncat(tempBuffer, KeywordTree[DSNAttrNo].AttrValue, KeywordTree[DSNAttrNo].AttrLength);
		strcat(tempBuffer, colonString);
	}
	
	// set the index to i = KEY_SERVER to start copying the attributes from then onwards till KEY_MAX
	i = KEY_SERVER;
	lengthCopied = 0;
	totalLength = 0;
	do
	{
		strLen = strlen(tempBuffer);
		totalLength += strLen;
		if (strLen != 0 && BufferLength != 0 && lengthCopied < BufferLength-1)
		{
			if (BufferLength == SQL_NTS || (BufferLength > 0 && strLen+lengthCopied < BufferLength))
			{
				strcpy((char *)(OutConnectionString+lengthCopied), tempBuffer);
				lengthCopied += strLen;
			}
			else
			{
				strLen = BufferLength-lengthCopied;
				strcpyUTF8((char *)(OutConnectionString+lengthCopied), tempBuffer, strLen);
				lengthCopied = BufferLength-1;
				setDiagRec(DRIVER_ERROR, IDS_01_004);
				rc = SQL_SUCCESS_WITH_INFO;
			}
		}
		tempBuffer[0] = '\0';
		switch (i)
		{
		case KEY_SAVEFILE:
			if (KeywordTree[i].AttrRank != 0)
			{
				strcpy(tempBuffer, ConnectKeywords[i]);
				strcat(tempBuffer, equalString);
				strncat(tempBuffer, KeywordTree[i].AttrValue, KeywordTree[DSNAttrNo].AttrLength);
				strcat(tempBuffer, colonString);
			}
			break;
		case KEY_UID:
			sprintf(tempBuffer, "%s=%s;", ConnectKeywords[i], ConnectFieldItems->loginId);
			break;
		case KEY_PWD:
			sprintf(tempBuffer, "%s=%s;", ConnectKeywords[i], ConnectFieldItems->password);
			break;
		case KEY_CATALOG:
			if (strlen(ConnectFieldItems->catalog) == 0)
			{
				sprintf(tempBuffer, "%s=TRAFODION;", ConnectKeywords[i]);
			}
			else
			{
				sprintf(tempBuffer, "%s=%s;", ConnectKeywords[i], ConnectFieldItems->catalog);
			}
			break;
		case KEY_SCHEMA:
			sprintf(tempBuffer, "%s=%s;", ConnectKeywords[i], ConnectFieldItems->schema);
			break;
		case KEY_SERVER:
			if (ConnectFieldItems->server[0] != '\0')
				sprintf(tempBuffer, "%s=%s;", ConnectKeywords[i], ConnectFieldItems->server);
			break;
		default:
			break;
		}
	}
	while (i++ < KEY_MAX) ;
	if (StringLength2Ptr != NULL)
		*StringLength2Ptr = totalLength;
	return rc;
}

SQLRETURN CConnect::prepareForConnect(CONNECT_KEYWORD_TREE *KeywordTree, 
									  CONNECT_FIELD_ITEMS &connectFieldItems, 
									  short DSNAttrNo,
									  short	DSNType,
									  char	*ServerNameNTS)
{
	short	retCode;
	char	transError[128];

	// Initialize the Keyword Attributes
	connectFieldItems.loginId[0] = '\0';
	connectFieldItems.password[0] = '\0';
	connectFieldItems.schema[0] = '\0';
	connectFieldItems.catalog[0] = '\0';
	connectFieldItems.server[0] = '\0';
	
	switch (DSNType)
	{
	case UNKNOWN_DSN:
		if (DSNAttrNo != KEY_MAX)
		{
			if (KeywordTree[DSNAttrNo].AttrLength > 0 && KeywordTree[DSNAttrNo].AttrLength <= MAX_SQL_IDENTIFIER_LEN)
				strcpyUTF8(ServerNameNTS, (const char *)KeywordTree[DSNAttrNo].AttrValue, MAX_SQL_IDENTIFIER_LEN+1, KeywordTree[DSNAttrNo].AttrLength);
			else
			{
				setDiagRec(DRIVER_ERROR, IDS_IM_010);
				return SQL_ERROR;
			}
		}
		transError[0] = '\0';
		// Read DS Values (DS can now be only System DSN or User DSN)
		retCode = m_DSValue.readDSValues(ServerNameNTS, transError);

		switch (retCode)
		{
		case ERROR_SUCCESS:
			break;
		case DS_AS_KEY_NOT_FOUND:
			setDiagRec(DRIVER_ERROR, IDS_08_001_01, GetLastError());
			return SQL_ERROR;
		case DS_NOT_FOUND:
			setDiagRec(DRIVER_ERROR, IDS_IM_002);
			return SQL_ERROR;
		case DS_TRANSLATION_ERROR:
			if (transError[0] != '\0')
				setDiagRec(DRIVER_ERROR, IDS_TRANSLATE_ERROR);
			else
				setDiagRec(DRIVER_ERROR, IDS_TRANSLATE_ERROR, 0, transError);
			return SQL_ERROR;
		default:
			setDiagRec(DRIVER_ERROR, IDS_HY_000, GetLastError());
			return SQL_ERROR;
		}
		break;
	case DRIVER_KW_DSN:
		break;
	default:
		return SQL_ERROR;
	}
	if (KeywordTree[KEY_SERVER].AttrRank != 0 && KeywordTree[KEY_SERVER].AttrLength > 0)
		strcpyUTF8(connectFieldItems.server, KeywordTree[KEY_SERVER].AttrValue,
					sizeof(connectFieldItems.server), KeywordTree[KEY_SERVER].AttrLength);
	else
		strcpy(connectFieldItems.server, m_DSValue.m_DSServer);
	if (KeywordTree[KEY_CATALOG].AttrRank != 0 && KeywordTree[KEY_CATALOG].AttrLength > 0)
		strcpyUTF8(connectFieldItems.catalog, KeywordTree[KEY_CATALOG].AttrValue,
					sizeof(connectFieldItems.catalog), KeywordTree[KEY_CATALOG].AttrLength);
	else
		strcpy(connectFieldItems.catalog, m_DSValue.m_DSCatalog);
	
	if (KeywordTree[KEY_SCHEMA].AttrRank != 0 && KeywordTree[KEY_SCHEMA].AttrLength > 0)
	{
		if (KeywordTree[KEY_SCHEMA].AttrValue[0] == '{' && KeywordTree[KEY_SCHEMA].AttrValue[KeywordTree[KEY_SCHEMA].AttrLength-1] == '}')
		{
			int i,j;
			for (i=0,j=1; j<KeywordTree[KEY_SCHEMA].AttrLength-1; i++, j++)
			{
				connectFieldItems.schema[i] = KeywordTree[KEY_SCHEMA].AttrValue[j];
				if(KeywordTree[KEY_SCHEMA].AttrValue[j] == '}' && KeywordTree[KEY_PWD].AttrValue[j+1] == '}')
					j++; // The '}' character is escaped as '}}'
			}
			connectFieldItems.schema[i] = '\0';
		}
		else
			strcpyUTF8(connectFieldItems.schema, KeywordTree[KEY_SCHEMA].AttrValue,
						sizeof(connectFieldItems.schema), KeywordTree[KEY_SCHEMA].AttrLength);
	}
	else
		strcpy(connectFieldItems.schema, m_DSValue.m_DSSchema);
	if (KeywordTree[KEY_UID].AttrRank != 0 && KeywordTree[KEY_UID].AttrLength > 0)
	{
		if (KeywordTree[KEY_UID].AttrValue[0] == '{' && KeywordTree[KEY_UID].AttrValue[KeywordTree[KEY_UID].AttrLength-1] == '}')
		{
			int i,j;
			for (i=0, j=1; j<KeywordTree[KEY_UID].AttrLength-1; i++, j++)
			{
				connectFieldItems.loginId[i] = KeywordTree[KEY_UID].AttrValue[j];
				if(KeywordTree[KEY_UID].AttrValue[j] == '}' && KeywordTree[KEY_UID].AttrValue[j+1] == '}')
					j++; // The '}' character is escaped as '}}'	
			}
			connectFieldItems.loginId[i] = '\0';
		}
		else
			strcpyUTF8(connectFieldItems.loginId, KeywordTree[KEY_UID].AttrValue,
						sizeof(connectFieldItems.loginId), KeywordTree[KEY_UID].AttrLength);
	}
	else
		connectFieldItems.loginId[0] = '\0';
	if (KeywordTree[KEY_PWD].AttrRank != 0 && KeywordTree[KEY_PWD].AttrLength > 0)
	{
		if (KeywordTree[KEY_PWD].AttrValue[0] == '{' && KeywordTree[KEY_PWD].AttrValue[KeywordTree[KEY_PWD].AttrLength-1] == '}')
		{
			int i,j;
			for (i=0, j=1; j<KeywordTree[KEY_PWD].AttrLength-1; i++, j++)
			{
				connectFieldItems.password[i] = KeywordTree[KEY_PWD].AttrValue[j];
				if(KeywordTree[KEY_PWD].AttrValue[j] == '}' && KeywordTree[KEY_PWD].AttrValue[j+1] == '}')
					j++; // The '}' character is escaped as '}}'	
			}
			connectFieldItems.password[i] = '\0';
		}
		else
			strcpyUTF8(connectFieldItems.password, KeywordTree[KEY_PWD].AttrValue,
						sizeof(connectFieldItems.password), KeywordTree[KEY_PWD].AttrLength);
	}
	else
		connectFieldItems.password[0] = '\0';

	return SQL_SUCCESS;
}

SQLRETURN CConnect::AllocHandle(SQLSMALLINT HandleType, 
			SQLHANDLE InputHandle, 
			SQLHANDLE *OutputHandle)
{
	SQLRETURN				rc = SQL_SUCCESS;
	CStmt* pStmt;

	switch (HandleType)
	{
	case SQL_HANDLE_STMT:
		pStmt = new CStmt(InputHandle);
		if (pStmt != NULL)
		{
			if ((rc = pStmt->initialize()) == SQL_SUCCESS)
				*OutputHandle = pStmt;
			else
			{
				delete pStmt;
				rc = SQL_ERROR;
			}
		}
		else
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_001);
			rc = SQL_ERROR;
		}
		break;
	case SQL_HANDLE_DESC:
		*OutputHandle = new CDesc(InputHandle, SQL_DESC_MODE_UNKNOWN, SQL_DESC_ALLOC_USER);
		if (*OutputHandle != NULL)
		{
			m_DescCollect.push_back((CDesc*)(*OutputHandle));
		}
		else
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_001);
			rc = SQL_ERROR;
		}
		break;
	default:
		rc = SQL_ERROR;
		break;
	}
	return rc;
}
	
SQLRETURN CConnect::BrowseConnect(SQLCHAR *InConnectionString,
			SQLSMALLINT        StringLength1,
			SQLCHAR 		  *OutConnectionString,
			SQLSMALLINT        BufferLength,
			SQLSMALLINT       *StringLength2Ptr)
{

	SQLRETURN				rc = SQL_SUCCESS;
	SQLRETURN				rc1;
	CONNECT_KEYWORD_TREE	KeywordTree[KEY_MAX+1];
	CONNECT_FIELD_ITEMS		connectFieldItems;
	short					outputKeyword[KEY_MAX];
	short					i;
	short					DSNAttrNo;					
	short					DSNType;
	short					inStrLen;
	char					lcConnectionString[2048+1];
	char					ServerNameNTS[MAX_SQL_IDENTIFIER_LEN+1];
	char					tempBuffer[513];
	SQLSMALLINT				lengthCopied;
	SQLSMALLINT				totalLength;
	SQLSMALLINT				strLen;
		
	clearError();
	if (OutConnectionString != NULL)
		*OutConnectionString = 0;
	if (StringLength2Ptr != NULL)
		*StringLength2Ptr = 0;

	if (InConnectionString != NULL)
	{
		if (StringLength1 == SQL_NTS)
			inStrLen = strlen((const char *)InConnectionString);
		else
			inStrLen = StringLength1;
		if (inStrLen > sizeof(lcConnectionString)-1)
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_013);
			return SQL_ERROR;
		}
		strcpyUTF8(lcConnectionString, (const char *)InConnectionString, sizeof(lcConnectionString), inStrLen);
	}
	else
	{
		strcpy(lcConnectionString, "DSN=DEFAULT;");
		inStrLen = strlen(lcConnectionString);
	}	
	
	ScanConnectString(lcConnectionString, inStrLen, KeywordTree);
	
	if (KeywordTree[KEY_DSN].AttrRank != 0)
	{
		DSNAttrNo = KEY_DSN;
		DSNType = UNKNOWN_DSN;
	}
	else
	if (KeywordTree[KEY_DRIVER].AttrRank != 0)
	{
		DSNAttrNo = KEY_DRIVER;		
		DSNType = DRIVER_KW_DSN;
	}
	else
	{
		DSNType = UNKNOWN_DSN;
		strcpy(ServerNameNTS, "DEFAULT");
		DSNAttrNo = KEY_MAX;
	}
	for (i = 0; i < KEY_MAX ; i++)
		outputKeyword[i] = KEY_MAX;
	i = 0;
	if (KeywordTree[KEY_UID].AttrRank == 0)
	{
		outputKeyword[i++] = KEY_UID;
		rc = SQL_NEED_DATA;
	}
	if (KeywordTree[KEY_PWD].AttrRank == 0)
	{
		outputKeyword[i++] = KEY_PWD;
		rc = SQL_NEED_DATA;
	}
	if (KeywordTree[KEY_DRIVER].AttrRank != 0)
	{
		if (KeywordTree[KEY_SERVER].AttrRank == 0)
		{
			outputKeyword[i++] = KEY_SERVER;
			rc = SQL_NEED_DATA;
		}
		if (KeywordTree[KEY_CATALOG].AttrRank == 0)
		{
			outputKeyword[i++] = KEY_CATALOG;
			rc = SQL_NEED_DATA;
		}
		if (KeywordTree[KEY_SCHEMA].AttrRank == 0)
		{
			outputKeyword[i++] = KEY_SCHEMA;
			rc = SQL_NEED_DATA;
		}
	}
	if (rc != SQL_NEED_DATA)
	{
		if ((rc = prepareForConnect(KeywordTree, connectFieldItems, DSNAttrNo, DSNType, ServerNameNTS)) != SQL_ERROR)
		{
			rc = Connect((SQLCHAR *)ServerNameNTS,
				SQL_NTS,
				(SQLCHAR *)connectFieldItems.loginId,
				SQL_NTS,
				(SQLCHAR *)connectFieldItems.password,
				SQL_NTS,
				FALSE);
		}
		if (rc != SQL_ERROR)
		{
			rc1 = generateConnectionString((CONNECT_KEYWORD_TREE *)&KeywordTree, &connectFieldItems, DSNAttrNo, OutConnectionString, 
				BufferLength, StringLength2Ptr);
			if (rc1 == SQL_SUCCESS_WITH_INFO)
				rc = rc1;
		}
	}
	else
	{
		lengthCopied = 0;
		totalLength = 0;

		for (i = 0; i < KEY_MAX && outputKeyword[i] != KEY_MAX ; i++)
		{
			sprintf(tempBuffer, "%s:%s=?;", ConnectKeywords[outputKeyword[i]],
											ConnectLocalizedIdentifier[outputKeyword[i]]);
			strLen = strlen(tempBuffer);
			totalLength += strLen;
			if (strLen != 0 && BufferLength != 0 && lengthCopied < BufferLength-1)
			{
				if (BufferLength == SQL_NTS || (BufferLength > 0 && strLen+lengthCopied < BufferLength))
				{
					if (OutConnectionString != NULL)
						strcpy((char *)(OutConnectionString+lengthCopied), tempBuffer);
					lengthCopied += strLen;
				}
				else
				{
					strLen = BufferLength-lengthCopied;
					if (OutConnectionString != NULL)
						strcpyUTF8((char *)(OutConnectionString+lengthCopied), tempBuffer, strLen);
					lengthCopied = BufferLength-1;
					setDiagRec(DRIVER_ERROR, IDS_01_004);
				}
			}
		}
		if (StringLength2Ptr != NULL)
			*StringLength2Ptr = totalLength;
	}
	if (rc == SQL_NEED_DATA) 
		m_CurrentOdbcAPI = SQL_API_SQLBROWSECONNECT;
	return rc;
}
	


SQLRETURN CConnect::DriverConnect(SQLHWND WindowHandle,
			SQLCHAR			*InConnectionString,
			SQLSMALLINT     StringLength1,
			SQLCHAR         *OutConnectionString,
			SQLSMALLINT     BufferLength,
			SQLSMALLINT 	*StringLength2Ptr,
			SQLUSMALLINT    DriverCompletion)
{
	CONNECT_KEYWORD_TREE	KeywordTree[KEY_MAX+1];
	CONNECT_FIELD_ITEMS		connectFieldItems;
	BOOL					reqAttrGiven = TRUE;
	short					DSNAttrNo;					
	short					DSNType;
	SQLRETURN				rc;
	SQLRETURN				rc1;
	short					inStrLen;
	char					lcConnectionString[2048+1];
	int						DialogRetCode;
	char					ServerNameNTS[MAX_SQL_IDENTIFIER_LEN+1];
	ServerNameNTS[0]=0;

	clearError();

	if (OutConnectionString != NULL)
		*OutConnectionString = 0;
	if (StringLength2Ptr != NULL)
		*StringLength2Ptr = 0;
	
	// FILEDSN is implemented by DM, DM reads the file datasource and gives it us either with DRIVER 
	// keyword or DSN keyword or both. Refer Driver Manager Guidelines under SQLDriverConnect
	// The code below attempts to follow Driver Guidelines under SQLDriverConnect
	if (InConnectionString != NULL)
	{
		if (StringLength1 == SQL_NTS)
			inStrLen = strlen((const char *)InConnectionString);
		else
			inStrLen = StringLength1;
		if (inStrLen > sizeof(lcConnectionString)-1)
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_013);
			return SQL_ERROR;
		}
		strcpyUTF8(lcConnectionString, (const char *)InConnectionString, sizeof(lcConnectionString), inStrLen);
	}
	else
	{
		strcpy(lcConnectionString, "DSN=DEFAULT;");
		inStrLen = strlen(lcConnectionString);
	}

	ScanConnectString(lcConnectionString, inStrLen, KeywordTree);
	if (KeywordTree[KEY_DSN].AttrRank != 0)
	{
		DSNAttrNo = KEY_DSN;
		DSNType = UNKNOWN_DSN;
		if ((KeywordTree[KEY_UID].AttrRank == 0) || (KeywordTree[KEY_PWD].AttrRank == 0))
			reqAttrGiven = FALSE;
	}
	else
	if (KeywordTree[KEY_DRIVER].AttrRank != 0)
	{
		DSNAttrNo = KEY_DRIVER;		
		DSNType = DRIVER_KW_DSN;
		if ((KeywordTree[KEY_UID].AttrRank == 0) || (KeywordTree[KEY_PWD].AttrRank == 0) ||
					(KeywordTree[KEY_SERVER].AttrRank == 0))
			reqAttrGiven = FALSE;
	}
	else
	{
		DSNType = UNKNOWN_DSN;
		strcpy(ServerNameNTS, "DEFAULT");
		DSNAttrNo = KEY_MAX;
	}
	if ((rc = prepareForConnect(KeywordTree, connectFieldItems, DSNAttrNo, DSNType, ServerNameNTS)) == SQL_ERROR)
		return SQL_ERROR;	
	switch (DriverCompletion)
	{
	case SQL_DRIVER_NOPROMPT:
		if (! reqAttrGiven)
		{
			setDiagRec(DRIVER_ERROR, IDS_28_000);
			return SQL_ERROR;
		}
		break;
	// Don't want the clutter the dialog box with all the optional fields
	// Hence SQL_DRIVER_COMPLETE_REQUIRED is same as SQL_DRIVER_COMPLETE
	case SQL_DRIVER_COMPLETE_REQUIRED:	
	case SQL_DRIVER_COMPLETE:	
		if (reqAttrGiven)			
			break;
	case SQL_DRIVER_PROMPT:				// No break, should fall thru
		m_ChangePassword = TRUE; // Rajani - for password expiry
		if (WindowHandle == NULL)
		{
			setDiagRec(DRIVER_ERROR, IDS_IM_008);
			return SQL_ERROR;
		}
		if(IsWindow(WindowHandle) == 0)
		{
			setDiagRec(DRIVER_ERROR, IDS_IM_008);
			return SQL_ERROR;
		}
		// Synchronize, since DialogProc uses a static variable
//		EnterCriticalSection(&m_CSObject);

		if (DSNType == DRIVER_KW_DSN) {
			DialogRetCode=TRUE;
			HINSTANCE hinst = LoadLibrary(ODBC_RESOURCE_DLL);
			if (hinst != NULL) {
				BOOL b=EnableWindow(WindowHandle,FALSE);
				HWND hWndDlg=CreateDialog(hinst,
				   MAKEINTRESOURCE(IDD_CONNECT_DRIVER_KW_DIALOG),
				   WindowHandle, ConnectDriverKWDialogProc);
				SetWindowLongPtr(hWndDlg,DWLP_USER,(LONG_PTR)&connectFieldItems);
				SendMessage(hWndDlg,WM_INITDIALOG,0,0);
				ShowWindow(hWndDlg,SW_SHOW);
				MSG msg;
				while (GetMessage(&msg,hWndDlg,0,0)) {
				 if (!IsWindow(hWndDlg) || !IsDialogMessage(hWndDlg,&msg)){
					 TranslateMessage(&msg);
					 DispatchMessage(&msg);
				 }
				}
				
				DestroyWindow(hWndDlg);
				EnableWindow(WindowHandle,!b);
				FreeLibrary(hinst);

				if (msg.wParam == 1)//IDCANCEL
				{
					setDiagRec(DRIVER_ERROR, IDS_HY_000, 0, "Operation Aborted.");
					return SQL_ERROR;
				}
			 }
			 else {
				BOOL b=EnableWindow(WindowHandle,FALSE);
				HWND hWndDlg=CreateDialog(gDrvrGlobal.gModuleHandle,
				   MAKEINTRESOURCE(IDD_CONNECT_DRIVER_KW_DIALOG),
				   WindowHandle, ConnectDriverKWDialogProc);
				SetWindowLongPtr(hWndDlg,DWLP_USER,(LONG_PTR)&connectFieldItems);
				SendMessage(hWndDlg,WM_INITDIALOG,0,0);
				ShowWindow(hWndDlg,SW_SHOW);  
				MSG msg;
				while (GetMessage(&msg,hWndDlg,0,0)) {
				 if (!IsWindow(hWndDlg) || !IsDialogMessage(hWndDlg,&msg)){
					 TranslateMessage(&msg);
					 DispatchMessage(&msg);
				 }
				}
				DestroyWindow(hWndDlg);
				EnableWindow(WindowHandle,!b);
				FreeLibrary(hinst);

				if (msg.wParam == 1)//IDCANCEL
				{
					setDiagRec(DRIVER_ERROR, IDS_HY_000, 0, "Operation Aborted.");
					return SQL_ERROR;
				}
			 }

		}
		else {
			//DialogRetCode = DialogBoxParam(gDrvrGlobal.gModuleHandle,
			//	 MAKEINTRESOURCE(IDD_CONNECT_DIALOG),
			//	 WindowHandle, ConnectDialogProc, (long)&connectFieldItems);
			HINSTANCE hinst = LoadLibrary(ODBC_RESOURCE_DLL);
			if (hinst != NULL) {
				DialogRetCode = DialogBoxParam(hinst,
					MAKEINTRESOURCE(IDD_CONNECT_DIALOG),
					WindowHandle, ConnectDialogProc, (LONG_PTR)&connectFieldItems);
				FreeLibrary(hinst);
			}
			else {
				DialogRetCode = DialogBoxParam(gDrvrGlobal.gModuleHandle,
					MAKEINTRESOURCE(IDD_CONNECT_DIALOG),
					WindowHandle, ConnectDialogProc, (LONG_PTR)&connectFieldItems);
			}
		}

//		LeaveCriticalSection(&m_CSObject);
		if (DialogRetCode == FALSE)
		{
			setDiagRec(DRIVER_ERROR, IDS_IM_008);
			return SQL_ERROR;
		}
		break;
	default:
		setDiagRec(DRIVER_ERROR, IDS_HY_110);
		return SQL_ERROR;
	}
	// Update the m_DSValue with what is in the connectionString and dialogbox 
	m_DSValue.updateDSValues(DSNType, &connectFieldItems, (CONNECT_KEYWORD_TREE *)&KeywordTree);
	rc = Connect((SQLCHAR *)ServerNameNTS,
			SQL_NTS,
			(SQLCHAR *)connectFieldItems.loginId,
			SQL_NTS,
			(SQLCHAR *)connectFieldItems.password,
			SQL_NTS,
			FALSE);

	if (rc != SQL_ERROR)
	{
		rc1 = generateConnectionString((CONNECT_KEYWORD_TREE *)&KeywordTree, &connectFieldItems, DSNAttrNo, OutConnectionString, 
				BufferLength, StringLength2Ptr);
		if (rc1 == SQL_SUCCESS_WITH_INFO)
			rc = rc1;
	}
	return rc;
}
	
	
SQLRETURN CConnect::SetConnectAttr(SQLINTEGER Attribute, SQLUINTEGER ValueNum, SQLPOINTER ValueStr, bool bClearErrors)
{
	SQLRETURN			rc = SQL_SUCCESS;
	SRVR_CALL_CONTEXT	srvrCallContext;

	if (bClearErrors)
		clearError();
	m_CurrentOdbcAPI = SQL_API_SQLSETCONNECTATTR;

	m_srvrCallContext.odbcAPI = SQL_API_SQLSETCONNECTATTR;
	m_srvrCallContext.sqlHandle = this;
	m_srvrCallContext.SQLSvc_ObjRef = m_SQLSvc_ObjRef;
	m_srvrCallContext.ASSvc_ObjRef = m_ASSvc_ObjRef;
	m_srvrCallContext.eventHandle = m_ConnectEvent;
	srvrCallContext.dialogueId = m_DialogueId;
	m_srvrCallContext.connectionTimeout = m_ConnectionTimeout;
	m_srvrCallContext.u.setConnectParams.attribute = Attribute;
	m_srvrCallContext.u.setConnectParams.valueNum = ValueNum;
	m_srvrCallContext.u.setConnectParams.valueStr = ValueStr;
	m_srvrCallContext.maxRowsetSize=-1;

	rc = ThreadControlProc(&m_srvrCallContext);
	if (rc == SQL_SUCCESS)
		if (m_SqlWarning)
			rc = SQL_SUCCESS_WITH_INFO;
	return rc;
}

SQLRETURN CConnect::SetConnectAttr(SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength)
{
	SQLRETURN	rc = SQL_SUCCESS;
	SQLINTEGER	strLen;
	char		Temp_Catalog[MAX_SQL_IDENTIFIER_LEN+1];
	CHANDLECOLLECT::iterator i;
	int translen = 0;
	int j;
	char		errorMsg[MAX_TRANSLATE_ERROR_MSG_LEN];

	Temp_Catalog[0] = '\0';

	switch (Attribute)
	{
	case SQL_ATTR_ACCESS_MODE:
	case SQL_ATTR_ASYNC_ENABLE:
	case SQL_ATTR_AUTOCOMMIT:
	case SQL_ATTR_CONNECTION_TIMEOUT:
	case SQL_ATTR_LOGIN_TIMEOUT:
	case SQL_ATTR_METADATA_ID:
	case SQL_ATTR_ODBC_CURSORS:
	case SQL_ATTR_TRANSLATE_OPTION:
	case SQL_ATTR_TXN_ISOLATION:
	case SQL_MAX_ROWS:
	case SQL_MAX_LENGTH:
	case SQL_NOSCAN:
	case SQL_QUERY_TIMEOUT:
	case SQL_ATTR_SESSIONNAME:
	case SQL_ATTR_FETCHAHEAD:
	case SQL_ATTR_ROLENAME:
	case SQL_ATTR_CERTIFICATE_DIR:
	case SQL_ATTR_CERTIFICATE_FILE:
	case SQL_ATTR_CERTIFICATE_FILE_ACTIVE:
	case SQL_START_NODE:
		break;
	//wms_mapping 
	case SQL_ATTR_APPLNAME:
		break;
	case SQL_ATTR_QUIET_MODE:
		if (StringLength != 0 && StringLength != SQL_IS_POINTER)
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_090);
			rc = SQL_ERROR;
		}
		break;
	case SQL_ATTR_CURRENT_CATALOG:
	case SQL_ATTR_TRANSLATE_LIB:
		if (StringLength == SQL_NTS)
			strLen = wcslen((const wchar_t *)ValuePtr) * 2;
		else
			strLen = StringLength;
		break;
	case SQL_ATTR_AUTO_IPD:
	case SQL_ATTR_PACKET_SIZE:
		setDiagRec(DRIVER_ERROR, IDS_HY_092);
		rc = SQL_ERROR;
		break;
	case SQL_ATTR_TRACE:			// Implemented by DM
	case SQL_ATTR_TRACEFILE:
		break;
	case SQL_ATTR_ROWSET_RECOVERY:
	case SQL_ATTR_FETCH_BUFFER_SIZE:
		break;
	case SQL_ATTR_CONCURRENCY:
	case SQL_ATTR_CURSOR_TYPE:
	case SQL_ATTR_SIMULATE_CURSOR:
	case SQL_ATTR_USE_BOOKMARKS:
	default:
		setDiagRec(DRIVER_ERROR, IDS_HY_092);
		rc = SQL_ERROR;
	}
	
	if (rc == SQL_ERROR)
		return rc;

	switch (Attribute)
	{
	case SQL_ATTR_ACCESS_MODE:
		if (m_ConnectionDead != SQL_CD_TRUE)
			rc = SetConnectAttr(Attribute, (SQLUINTEGER)ValuePtr, NULL);
		if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)	
			m_AccessMode = (SQLUINTEGER)ValuePtr;
		break;
	case SQL_ATTR_ASYNC_ENABLE:
		m_AsyncEnable = (SQLUINTEGER)ValuePtr;
		for (i = m_StmtCollect.begin() ; i !=  m_StmtCollect.end() ; ++i)
			((CStmt *)(*i))->m_AsyncEnable = m_AsyncEnable;
		break;
	case SQL_ATTR_AUTOCOMMIT:
		if (m_ConnectionDead != SQL_CD_TRUE)
		{
			if ( (m_AutoCommit == SQL_AUTOCOMMIT_ON && (SQLUINTEGER)ValuePtr != SQL_AUTOCOMMIT_ON)
			|| (m_AutoCommit == SQL_AUTOCOMMIT_OFF && (SQLUINTEGER)ValuePtr != SQL_AUTOCOMMIT_OFF) )
			{
				rc = SetConnectAttr(Attribute, (SQLUINTEGER)ValuePtr, NULL);
			}

		}
		if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)
			m_AutoCommit = (SQLUINTEGER)ValuePtr;
		break;
	case SQL_ATTR_CONNECTION_TIMEOUT:
		m_ConnectionTimeout = (SQLUINTEGER)ValuePtr;
		break;
	case SQL_ATTR_CURRENT_CATALOG:
		if (strLen/2 >= sizeof(m_CurrentCatalog))
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_090);
			rc = SQL_ERROR;
		}
		else
		{
			if(strLen > 0)
			{
				if(WCharToUTF8((wchar_t *)ValuePtr, strLen/2, Temp_Catalog, sizeof(Temp_Catalog), &translen, errorMsg) != SQL_SUCCESS)
					return SQL_ERROR;
			}
			else
				Temp_Catalog[0] = '\0';
			
			if (m_ConnectionDead != SQL_CD_TRUE)
				rc = SetConnectAttr(Attribute, 0, Temp_Catalog);
			if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)	
			{
				strcpy(m_CurrentCatalog, Temp_Catalog);
			}
		}
		break;
	case SQL_ATTR_LOGIN_TIMEOUT:
		m_LoginTimeout = (SQLUINTEGER)ValuePtr;
		break;
	case SQL_ATTR_METADATA_ID:
		m_MetadataId = (SQLUINTEGER)ValuePtr;
		for (i = m_StmtCollect.begin() ; i !=  m_StmtCollect.end() ; ++i)
			((CStmt *)(*i))->m_MetadataId = m_MetadataId;
		break;
	case SQL_ATTR_ODBC_CURSORS:
		if (m_ConnectionDead == SQL_CD_FALSE)
			m_ODBCCursors = (SQLUINTEGER)ValuePtr;
		else
		{
			setDiagRec(DRIVER_ERROR, IDS_08_002);
			rc = SQL_ERROR;
		}
		break;
	case SQL_ATTR_QUIET_MODE:
		m_QuietMode = (HWND)ValuePtr;
		break;
	case SQL_ATTR_TRANSLATE_LIB:
		if (strLen >= sizeof(m_TranslateLib))
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_090);
			rc = SQL_ERROR;
		}
		else
		{
			strncpy(m_TranslateLib, (const char *)ValuePtr, strLen);
			m_TranslateLib[strLen] = '\0';
		}
//		rc = InitializeTranslation();
		break;
	case SQL_ATTR_TRANSLATE_OPTION:
		m_TranslateOption = (SQLUINTEGER)ValuePtr;
		break;
	case SQL_ATTR_TXN_ISOLATION:
		if (m_ConnectionDead != SQL_CD_TRUE)
			rc = SetConnectAttr(Attribute, (SQLUINTEGER)ValuePtr, NULL);
		if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)	
			m_TxnIsolation = (SQLUINTEGER)ValuePtr;
		break;
	case SQL_ATTR_TRACE:			// Implemented by DM
	case SQL_ATTR_TRACEFILE:
		break;
	case SQL_ATTR_CONCURRENCY:
		break;
	case SQL_ATTR_CURSOR_TYPE:
		break;
	case SQL_ATTR_SIMULATE_CURSOR:
		break;
	case SQL_ATTR_USE_BOOKMARKS:
		if ((SQLUINTEGER)ValuePtr == SQL_UB_ON)
		{
			setDiagRec(DRIVER_ERROR, IDS_01_S02);
			rc = SQL_SUCCESS_WITH_INFO;
		}
		break;
	case SQL_MAX_ROWS:
		m_MaxRows = (SQLUINTEGER)ValuePtr;
		break;
	case SQL_MAX_LENGTH:
		m_MaxLength = (SQLUINTEGER)ValuePtr;
		break;
	case SQL_NOSCAN:
		m_Noscan = (SQLUINTEGER)ValuePtr;
		break;
	case SQL_QUERY_TIMEOUT:
		m_QueryTimeout = (SQLUINTEGER)ValuePtr;
		if(m_QueryTimeout != 0 && m_QueryTimeout < 30)
			m_QueryTimeout = 30;
		break;
	case SQL_ATTR_ROWSET_RECOVERY:
		if (m_ConnectionDead != SQL_CD_TRUE)
			rc = SetConnectAttr(Attribute, (SQLUINTEGER)ValuePtr, NULL);
		else
			rc = SQL_ERROR;
		if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)	
			m_RowsetErrorRecovery = (SQLINTEGER)ValuePtr;
		break;
	case SQL_ATTR_FETCH_BUFFER_SIZE:
		m_FetchBufferSize = (SQLINTEGER)ValuePtr;
		if (m_FetchBufferSize < 0)
			m_FetchBufferSize = 0;
		m_FetchBufferSize *= 1024;
		break;
	// Trafodion Extension to set the Session Name part of Unique Query ID
	case SQL_ATTR_SESSIONNAME:
		{
			if (StringLength == SQL_NTS)
				strLen = wcslen((const wchar_t *)ValuePtr);
			else
				strLen = StringLength/2;

			for(j = 0; j < strLen; j++)
			{
				wint_t ch = (*(unsigned wchar_t *)((wchar_t *)ValuePtr + j));
				if(!iswalnum(ch) && ch != L'_')
				{
					setDiagRec(DRIVER_ERROR, IDS_HY_000, 0, "Illegal characters in the Session Name attribute.");
					rc = SQL_ERROR;
					break;
				}
			}

			if(strLen > SQL_MAX_SESSIONNAME_LEN-1)
			{
				strLen = SQL_MAX_SESSIONNAME_LEN-1;
				setDiagRec(DRIVER_ERROR, IDS_HY_000, 0, "The maximum length for Session Name, 24 characters, has been exceeded.");
				rc = SQL_SUCCESS_WITH_INFO;
			}
			if(rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO)
			{
				if(strLen > 0)
				{
					if(WCharToUTF8((wchar_t *)ValuePtr, strLen, m_QueryID_SessionName, sizeof(m_QueryID_SessionName), &translen, errorMsg) != SQL_SUCCESS)
						return SQL_ERROR;
				}
				else
					m_QueryID_SessionName[0] = '\0';
			}
		}
		break;
	case SQL_ATTR_ROLENAME:
		if (StringLength == SQL_NTS)
			strLen = wcslen((const wchar_t *)ValuePtr) *2;
		else
			strLen = StringLength;
		for(j = 0; j < strLen/2; j++)
		{
			wint_t ch = (*(unsigned wchar_t *)((wchar_t *)ValuePtr + j));
			if(!iswalnum(ch) && ch != L'_')
			{
				setDiagRec(DRIVER_ERROR, IDS_HY_000, 0, "Illegal characters in the Role Name attribute.");
				rc = SQL_ERROR;
				break;
			}
		}
		if(rc == SQL_SUCCESS)
		{
			if(strLen > 0)
			{
				if(WCharToUTF8((wchar_t *)ValuePtr, strLen/2, m_UserRole, sizeof(m_UserRole), &translen, errorMsg) != SQL_SUCCESS)
					return SQL_ERROR;
			}
			else
				m_UserRole[0] = '\0';
			if(rc == SQL_SUCCESS_WITH_INFO)
			{
				setDiagRec(DRIVER_ERROR, IDS_HY_090);
				rc = SQL_ERROR;
				break;
			}
		}
		break;
	case SQL_ATTR_FETCHAHEAD:
		if ((SQLINTEGER)ValuePtr != 0 && (SQLINTEGER)ValuePtr != 1)
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_000, 0, "Illegal value specified. Valid value is 0 or 1.");
			rc = SQL_ERROR;
			break;
		}
		m_FetchAhead = (SQLINTEGER)ValuePtr;
		break;
	//wms_mapping 
	case SQL_ATTR_APPLNAME:
		if (StringLength == SQL_NTS)
			strLen = wcslen((const wchar_t *)ValuePtr) * 2;
		else
			strLen = StringLength;
		strLen = strLen > sizeof(m_applName)-1 ? sizeof(m_applName)-1 : strLen;

			if(strLen > 0)
			{
				if(WCharToUTF8((wchar_t *)ValuePtr, strLen/2, m_applName, sizeof(m_applName), &translen, errorMsg) != SQL_SUCCESS)
					return SQL_ERROR;
			}
			else
				m_applName[0] = '\0';
			if(rc == SQL_SUCCESS_WITH_INFO)
			{
				setDiagRec(DRIVER_ERROR, IDS_HY_090);
				rc = SQL_ERROR;
				break;
			}
		break;
	case SQL_ATTR_CERTIFICATE_DIR:
		if (StringLength == SQL_NTS)
			strLen = wcslen((const wchar_t *)ValuePtr) * 2;
		else
			strLen = StringLength;

		strLen = strLen > sizeof(m_CertificateDir)-1 ? sizeof(m_CertificateDir)-1 : strLen;
		if(strLen > 0)
		{
			if(WCharToUTF8((wchar_t *)ValuePtr, strLen/2, m_CertificateDir, sizeof(m_CertificateDir), &translen, errorMsg) != SQL_SUCCESS)
				return SQL_ERROR;
		}
		else
			m_CertificateDir[0] = '\0';
		if(rc == SQL_SUCCESS_WITH_INFO)
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_090);
			rc = SQL_ERROR;
			break;
		}
		break;
	case SQL_ATTR_CERTIFICATE_FILE:
		if (StringLength == SQL_NTS)
			strLen = wcslen((const wchar_t *)ValuePtr) * 2;
		else
			strLen = StringLength;
		strLen = strLen > sizeof(m_CertificateFile)-1 ? sizeof(m_CertificateFile)-1 : strLen;
		if(strLen > 0)
		{
			if(WCharToUTF8((wchar_t *)ValuePtr, strLen/2, m_CertificateFile, sizeof(m_CertificateFile), &translen, errorMsg) != SQL_SUCCESS)
				return SQL_ERROR;
		}
		else
			m_CertificateFile[0] = '\0';
		if(rc == SQL_SUCCESS_WITH_INFO)
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_090);
			rc = SQL_ERROR;
			break;
		}
		break;
	case SQL_ATTR_CERTIFICATE_FILE_ACTIVE:
		if (StringLength == SQL_NTS)
			strLen = wcslen((const wchar_t *)ValuePtr) * 2;
		else
			strLen = StringLength;

		strLen = strLen > sizeof(m_CertificateFileActive)-1 ? sizeof(m_CertificateFileActive)-1 : strLen;

		if(strLen > 0)
		{
			if(WCharToUTF8((wchar_t *)ValuePtr, strLen/2, m_CertificateFileActive, sizeof(m_CertificateFileActive), &translen, errorMsg) != SQL_SUCCESS)
				return SQL_ERROR;
		}
		else
			m_CertificateFileActive[0] = '\0';
		if(rc == SQL_SUCCESS_WITH_INFO)
		{
			setDiagRec(DRIVER_ERROR, IDS_HY_090);
			rc = SQL_ERROR;
			break;
		}
		break;
	case SQL_START_NODE:
		m_StartNode = (SQLINTEGER)ValuePtr;
		break;
	default:
		setDiagRec(DRIVER_ERROR, IDS_HY_092);
		rc = SQL_ERROR;
		break;
	}
	return rc;
}

SQLRETURN CConnect::GetConnectAttr(SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER BufferLength,
								   SQLINTEGER *StringLengthPtr)
{
	SQLRETURN				rc = SQL_SUCCESS;
	RETURN_VALUE_STRUCT		retValue;
	BOOL					encrypt = false;
	short retCode=SQL_SUCCESS;

	clearError();
	m_CurrentOdbcAPI = SQL_API_SQLGETCONNECTATTR;
	retValue.dataType = DRVR_PENDING;
	retValue.u.strPtr = NULL;
	
	switch (Attribute)
	{
	case SQL_ATTR_ACCESS_MODE:
		retValue.u.u32Value = m_AccessMode;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_ASYNC_ENABLE:
		retValue.u.u32Value = m_AsyncEnable;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_AUTOCOMMIT:
		retValue.u.u32Value = m_AutoCommit;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_AUTO_IPD:
		retValue.u.u32Value = m_AutoIPD;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_CONNECTION_TIMEOUT:
		retValue.u.u32Value = m_ConnectionTimeout;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_CURRENT_CATALOG:
		retValue.u.strPtr = m_CurrentCatalog;
		break;
	case SQL_ATTR_LOGIN_TIMEOUT:
		retValue.u.u32Value = m_LoginTimeout;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_METADATA_ID:
		retValue.u.u32Value = m_MetadataId;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_ODBC_CURSORS:
		retValue.u.u32Value = m_ODBCCursors;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_PACKET_SIZE:
		retValue.u.u32Value = m_PacketSize;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_QUIET_MODE:
		retValue.u.pValue = m_QuietMode;
		retValue.dataType = SQL_IS_POINTER;
		break;
	case SQL_ATTR_TRANSLATE_LIB:
		retValue.u.strPtr = m_TranslateLib;
		break;
	case SQL_ATTR_TRANSLATE_OPTION:
		retValue.u.u32Value = m_TranslateOption;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_TXN_ISOLATION:
		retValue.u.u32Value = m_TxnIsolation;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_TRACE:			// Implemented by DM
	case SQL_ATTR_TRACEFILE:
		break;
	case SQL_ATTR_CONCURRENCY:
		retValue.u.u32Value = m_Concurrency;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_CURSOR_TYPE:
		retValue.u.u32Value = m_CursorType;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_MAX_LENGTH:
#ifdef _WIN64
		retValue.u.s64Value = m_MaxLength;
		retValue.dataType = SQL_C_UBIGINT;
#else
		retValue.u.u32Value = m_MaxLength;
		retValue.dataType = SQL_IS_UINTEGER;
#endif
		break;
	case SQL_ATTR_MAX_ROWS:
#ifdef _WIN64
		retValue.u.s64Value = m_MaxRows;
		retValue.dataType = SQL_C_UBIGINT;
#else
		retValue.u.u32Value = m_MaxRows;
		retValue.dataType = SQL_IS_UINTEGER;
#endif
		break;
	case SQL_ATTR_NOSCAN:
		retValue.u.u32Value = m_Noscan;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_QUERY_TIMEOUT:
		retValue.u.u32Value = m_QueryTimeout;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_SIMULATE_CURSOR:
		retValue.u.u32Value = m_SimulateCursor;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_USE_BOOKMARKS:
		retValue.u.u32Value = m_UseBookmarks;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_ROWSET_RECOVERY:
		retValue.u.u32Value = m_RowsetErrorRecovery;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ATTR_FETCH_BUFFER_SIZE:
		retValue.u.u32Value = m_FetchBufferSize/1024;
		retValue.dataType = SQL_IS_INTEGER;
		break;
	case SQL_ATTR_SESSIONNAME:
		retValue.u.strPtr = m_QueryID_SessionName;
		break;
	case SQL_ATTR_ROLENAME:
		retValue.u.strPtr = m_UserRole;
		break;
	case SQL_ATTR_FETCHAHEAD:
		retValue.u.u32Value = m_FetchAhead;
		break;
	//wms_mapping 
	case SQL_ATTR_APPLNAME:
		retValue.u.strPtr = m_applName;
		break;
	case SQL_ATTR_CERTIFICATE_DIR:
		retValue.u.strPtr = m_CertificateDir;
		break;
	case SQL_ATTR_CERTIFICATE_FILE:
		retValue.u.strPtr = m_CertificateFile;
		break;
	case SQL_ATTR_CERTIFICATE_FILE_ACTIVE:
		retValue.u.strPtr = m_CertificateFileActive;
		break;
	default:
		setDiagRec(DRIVER_ERROR, IDS_HY_092);
		break;
	}
	if (rc == SQL_SUCCESS && !encrypt)
		rc = returnAttrValue(TRUE, this, &retValue, ValuePtr, BufferLength, StringLengthPtr);
	return rc;
}

SQLRETURN CConnect::EndTran(SQLSMALLINT CompletionType)	
{
	SQLRETURN			rc;
	CHANDLECOLLECT::iterator i;

	clearError();
	if (m_ConnectionDead == SQL_CD_TRUE)
	{
		clearError();
		setDiagRec(DRIVER_ERROR, IDS_08_S01);
		rc = SQL_ERROR;
	}
	else
	{
		m_srvrCallContext.odbcAPI = SQL_API_SQLENDTRAN;
		m_srvrCallContext.sqlHandle = this;
		m_srvrCallContext.SQLSvc_ObjRef = m_SQLSvc_ObjRef;
		m_srvrCallContext.ASSvc_ObjRef = m_ASSvc_ObjRef;
		m_srvrCallContext.eventHandle = m_ConnectEvent;
		m_srvrCallContext.dialogueId = m_DialogueId;
		m_srvrCallContext.connectionTimeout = m_ConnectionTimeout;
		m_srvrCallContext.u.completionType = CompletionType;
		m_srvrCallContext.maxRowsetSize=-1;

		rc = ThreadControlProc(&m_srvrCallContext);
		if (rc == SQL_SUCCESS)
			if (m_SqlWarning)
				rc = SQL_SUCCESS_WITH_INFO;
	}
	switch (rc)
	{
	case SQL_SUCCESS:
	case SQL_SUCCESS_WITH_INFO:
		// SQL_CB_CLOSE behavior
		for (i = m_StmtCollect.begin() ; i !=  m_StmtCollect.end() ; ++i)
			((CStmt *)(*i))->revertStmtState();
		break;
	case SQL_STILL_EXECUTING:
	case SQL_NEED_DATA:
	case SQL_ERROR:
	case SQL_NO_DATA:
	case SQL_INVALID_HANDLE:
	default:
		break;
	}
	return rc;
}

SQLRETURN CConnect::GetInfo(SQLUSMALLINT InfoType, 
		   SQLPOINTER InfoValuePtr,
           SQLSMALLINT BufferLength,
		   SQLSMALLINT *StringLengthPtr)
{
	char					*cYes	= "Y";
	char					*cNo	= "N";
	char					*cPartial = "P"; // Based on 2.0 specification
	char					*cFull = "F";
	char					*cEmpty = "";
	char					tmpStr[32];
	char					*cKeywords = "ABS,AFTER,ALIAS,BEFORE,BOOLEAN,BREADTH,CALL,COMPLETION,"\
								   "CONVERTTIMESTAMP,CYCLE,DATEFORMAT,DAYOFWEEK,DEPTH,DICTIONARY,"\
								   "EACH,EQUALS,GENERAL,IF,IGNORE,INDEX_TABLE,INVOKE,JULIANTIMESTAMP,"\
								   "LEAVE,LESS,LIMIT,LOAD_TABLE,LOOP,MODIFY,NEW,OBJECT,OFF,OID,OLD,"\
								   "OPERATION,OPERATORS,OTHERS,PARAMETERS,PENDANT,PREORDER,PRIVATE,"\
								   "PROTECTED,PROTOTYPE,RECURSIVE,REF,REFERENCING,REPLACE,RESIGNAL,"\
								   "RESOURCE_FORK,RETURN,RETURNS,ROLE,ROUTINE,ROW,SAVEPOINT,SEARCH,"\
								   "SENSITIVE,SHOWDDL,SHOWPLAN,SIGNAL,SIMILAR,SQLEXCEPTION,STDDEV,"\
								   "STRUCTURE,TEST,THERE,TRANSPOSE,TRIGGER,TYPE,UNDER,UPSHIFT,"\
								   "VARIABLE,VARIANCE,VIRTUAL,WAIT,WHILE,WITHOUT";
	SQLRETURN				rc = SQL_SUCCESS;
	RETURN_VALUE_STRUCT		retValue;
	SQLINTEGER				lStringLength;

	clearError();
	m_CurrentOdbcAPI = SQL_API_SQLGETINFO;
	retValue.dataType = DRVR_PENDING;
	retValue.u.strPtr = NULL;

	switch (InfoType)
	{
	case SQL_ACCESSIBLE_PROCEDURES:	
		retValue.u.strPtr = cNo;
		break;
	case SQL_ACCESSIBLE_TABLES:	
		retValue.u.strPtr = cNo;
		break;
	case SQL_ACTIVE_ENVIRONMENTS:
		retValue.u.u16Value = 0;	
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_AGGREGATE_FUNCTIONS:
		retValue.u.u32Value = SQL_AF_AVG | SQL_AF_COUNT | SQL_AF_MAX | SQL_AF_MIN | SQL_AF_SUM;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ALTER_DOMAIN:
		retValue.u.u32Value = 0L; // Not supported
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ALTER_TABLE:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ASYNC_MODE:
		retValue.u.u32Value = SQL_AM_STATEMENT;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_BATCH_ROW_COUNT:
		retValue.u.u32Value = 0; 
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_BATCH_SUPPORT:
		retValue.u.u32Value = 0; 
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_BOOKMARK_PERSISTENCE:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CATALOG_LOCATION:
		retValue.u.u16Value = SQL_CL_START;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_CATALOG_NAME:
		retValue.u.strPtr = cYes;
		break;
	case SQL_CATALOG_NAME_SEPARATOR:
		retValue.u.strPtr = ".";
		break;
	case SQL_CATALOG_TERM:
		retValue.u.strPtr = "catalog";
		break;
	case SQL_CATALOG_USAGE:
		retValue.u.u32Value = SQL_QU_DML_STATEMENTS | SQL_QU_TABLE_DEFINITION | 
				SQL_QU_INDEX_DEFINITION;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_COLLATION_SEQ:
		retValue.u.strPtr = "ISO 8859-1";
		break;
	case SQL_COLUMN_ALIAS:
		retValue.u.strPtr = cYes;
		break;
	case SQL_CONCAT_NULL_BEHAVIOR:
		retValue.u.u16Value = SQL_CB_NULL;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_CONVERT_BIGINT:		
	case SQL_CONVERT_DECIMAL:               
	case SQL_CONVERT_DOUBLE:                
	case SQL_CONVERT_FLOAT:                 
	case SQL_CONVERT_INTEGER:               
	case SQL_CONVERT_NUMERIC:               
	case SQL_CONVERT_REAL:                  
	case SQL_CONVERT_SMALLINT:              
		retValue.u.u32Value = SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL
					| SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT
					| SQL_CVT_REAL | SQL_CVT_DOUBLE  | SQL_CVT_VARCHAR
					// | SQL_CVT_LONGVARCHAR
					// | SQL_CVT_TINYINT 
					| SQL_CVT_BIGINT;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CONVERT_CHAR:                  
	case SQL_CONVERT_VARCHAR: 
		retValue.u.u32Value = SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL
					| SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT
					| SQL_CVT_REAL | SQL_CVT_DOUBLE  | SQL_CVT_VARCHAR
					// | SQL_CVT_LONGVARCHAR 
					// | SQL_CVT_TINYINT 
					| SQL_CVT_BIGINT | SQL_CVT_DATE | SQL_CVT_TIME 
					| SQL_CVT_TIMESTAMP
					// | SQL_CVT_WCHAR | SQL_CVT_WVARCHAR;
					;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CONVERT_LONGVARCHAR:           
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CONVERT_DATE:                  
		retValue.u.u32Value =  SQL_CVT_CHAR | SQL_CVT_VARCHAR
			//		| SQL_CVT_LONGVARCHAR 
					| SQL_CVT_DATE | SQL_CVT_TIMESTAMP;
		
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CONVERT_TIME:                  
		retValue.u.u32Value = SQL_CVT_CHAR | SQL_CVT_VARCHAR
				//	| SQL_CVT_LONGVARCHAR 
					| SQL_CVT_TIME 	| SQL_CVT_TIMESTAMP;
		
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CONVERT_TIMESTAMP:             
		retValue.u.u32Value = SQL_CVT_CHAR | SQL_CVT_VARCHAR
				//	| SQL_CVT_LONGVARCHAR 
					| SQL_CVT_DATE | SQL_CVT_TIME 
					| SQL_CVT_TIMESTAMP;
		
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CONVERT_BIT:                   
	case SQL_CONVERT_BINARY:		
	case SQL_CONVERT_VARBINARY:             
	case SQL_CONVERT_LONGVARBINARY:         		
	case SQL_CONVERT_INTERVAL_DAY_TIME:
	case SQL_CONVERT_INTERVAL_YEAR_MONTH:
	case SQL_CONVERT_TINYINT:               
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CONVERT_WCHAR:
	case SQL_CONVERT_WVARCHAR:
		retValue.u.u32Value = SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL
					| SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT
					| SQL_CVT_REAL | SQL_CVT_DOUBLE  | SQL_CVT_VARCHAR
					//| SQL_CVT_LONGVARCHAR 
					// | SQL_CVT_TINYINT 
					| SQL_CVT_BIGINT | SQL_CVT_DATE | SQL_CVT_TIME 
					| SQL_CVT_TIMESTAMP
					| SQL_CVT_WCHAR | SQL_CVT_WVARCHAR;
				retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CONVERT_WLONGVARCHAR:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CONVERT_FUNCTIONS:
		retValue.u.u32Value = SQL_FN_CVT_CONVERT;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CORRELATION_NAME:
		retValue.u.u16Value = SQL_CN_ANY;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_CREATE_ASSERTION:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CREATE_CHARACTER_SET:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CREATE_COLLATION:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CREATE_DOMAIN:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CREATE_SCHEMA:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CREATE_TABLE:
		retValue.u.u32Value = SQL_CT_CREATE_TABLE;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CREATE_TRANSLATION:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CREATE_VIEW:
		retValue.u.u32Value = SQL_CV_CREATE_VIEW | SQL_CV_CHECK_OPTION | SQL_CV_CASCADED;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_CURSOR_COMMIT_BEHAVIOR:
	case SQL_CURSOR_ROLLBACK_BEHAVIOR:
		retValue.u.u16Value = SQL_CB_CLOSE;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_CURSOR_SENSITIVITY:
		retValue.u.u32Value = SQL_UNSPECIFIED;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_DATA_SOURCE_NAME:
		retValue.u.strPtr = m_DSValue.m_DSName;
		break;
	case SQL_DATA_SOURCE_READ_ONLY:
		if (m_SrvrDSReadType == 0) // Read only
			retValue.u.strPtr = cYes;
		else
			retValue.u.strPtr = cNo;
		break;
	case SQL_DATABASE_NAME:
		retValue.u.strPtr = m_CurrentCatalog;
		break;
	case SQL_DATETIME_LITERALS:
		retValue.u.u32Value = SQL_DL_SQL92_DATE | SQL_DL_SQL92_TIME | SQL_DL_SQL92_TIMESTAMP
				| SQL_DL_SQL92_INTERVAL_YEAR | SQL_DL_SQL92_INTERVAL_MONTH  //  not supported.
				| SQL_DL_SQL92_INTERVAL_DAY | SQL_DL_SQL92_INTERVAL_HOUR
				| SQL_DL_SQL92_INTERVAL_MINUTE | SQL_DL_SQL92_INTERVAL_SECOND
				| SQL_DL_SQL92_INTERVAL_YEAR_TO_MONTH | SQL_DL_SQL92_INTERVAL_DAY_TO_HOUR
				| SQL_DL_SQL92_INTERVAL_DAY_TO_MINUTE
				| SQL_DL_SQL92_INTERVAL_DAY_TO_SECOND | SQL_DL_SQL92_INTERVAL_HOUR_TO_MINUTE
				| SQL_DL_SQL92_INTERVAL_HOUR_TO_SECOND | SQL_DL_SQL92_INTERVAL_MINUTE_TO_SECOND;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_DBMS_NAME:
		retValue.u.strPtr = "Trafodion";
		break;
	case SQL_DBMS_VER:
		sprintf(tmpStr, "%02d.%02d.%04d", m_SqlVersion.majorVersion,
			m_SqlVersion.minorVersion, m_SqlVersion.buildId);
		retValue.u.strPtr = tmpStr;
		break;
	case SQL_DDL_INDEX:
		retValue.u.u32Value = SQL_DI_CREATE_INDEX | SQL_DI_DROP_INDEX;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_DEFAULT_TXN_ISOLATION:
		retValue.u.u32Value = SQL_TXN_READ_COMMITTED;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_DESCRIBE_PARAMETER:
		retValue.u.strPtr = cYes;
		break;
	case SQL_DM_VER: //		Implemented by DM
		break;
	case SQL_DRIVER_HDBC: //		Implemented by DM
	case SQL_DRIVER_HENV:
	case SQL_DRIVER_HDESC:
	case SQL_DRIVER_HLIB:
	case SQL_DRIVER_HSTMT:
		break;
	case SQL_DRIVER_NAME:
//		retValue.u.strPtr = gDrvrGlobal.gDriverDLLName;
		retValue.u.strPtr = DRIVER_DLL_NAME;
		break;
	case SQL_DRIVER_ODBC_VER:
		//sprintf(tmpStr, "%02d.%02d", gDrvrGlobal.gClientVersion.majorVersion,
		//	gDrvrGlobal.gClientVersion.minorVersion);
		sprintf(tmpStr, "%02d.%02d",3,51);
		retValue.u.strPtr = tmpStr;
		break;
	case SQL_DRIVER_VER:
		sprintf(tmpStr, "%02d.%02d.%04d", gDrvrGlobal.gClientVersion.majorVersion,
			gDrvrGlobal.gClientVersion.minorVersion, gDrvrGlobal.gClientVersion.buildId);
		retValue.u.strPtr = tmpStr;
		break;
	case SQL_DROP_ASSERTION:
	case SQL_DROP_CHARACTER_SET:		
	case SQL_DROP_COLLATION:			
	case SQL_DROP_DOMAIN:			
	case SQL_DROP_SCHEMA:
	case SQL_DROP_TRANSLATION:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_DROP_TABLE:
		retValue.u.u32Value = SQL_DT_DROP_TABLE | SQL_DT_RESTRICT | SQL_DT_CASCADE;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_DROP_VIEW:
		retValue.u.u32Value = SQL_DV_DROP_VIEW | SQL_DV_RESTRICT | SQL_DV_CASCADE;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_DYNAMIC_CURSOR_ATTRIBUTES1:	
	case SQL_DYNAMIC_CURSOR_ATTRIBUTES2:	
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_EXPRESSIONS_IN_ORDERBY:
		retValue.u.strPtr = cNo;						 // But we support column Number
		break;
	case SQL_FETCH_DIRECTION:
		retValue.u.u32Value = SQL_FD_FETCH_NEXT;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_FILE_USAGE:
		retValue.u.u16Value = SQL_FILE_NOT_SUPPORTED;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1:	
		retValue.u.u32Value = SQL_CA1_NEXT | SQL_CA1_SELECT_FOR_UPDATE;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2:	
		retValue.u.u32Value = SQL_CA2_READ_ONLY_CONCURRENCY | SQL_CA2_LOCK_CONCURRENCY 
					| SQL_CA2_MAX_ROWS_SELECT;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_GETDATA_EXTENSIONS:
		retValue.u.u32Value = SQL_GD_ANY_COLUMN | SQL_GD_ANY_ORDER | SQL_GD_BOUND;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_GROUP_BY:
		retValue.u.u16Value = SQL_GB_GROUP_BY_EQUALS_SELECT;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_IDENTIFIER_CASE:
		retValue.u.u16Value = SQL_IC_UPPER;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_IDENTIFIER_QUOTE_CHAR:				
		retValue.u.strPtr = "\"";
		break;
	case SQL_INDEX_KEYWORDS:
		retValue.u.u32Value = SQL_IK_ALL;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_INFO_SCHEMA_VIEWS:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_INSERT_STATEMENT:
		retValue.u.u32Value = SQL_IS_INSERT_LITERALS | SQL_IS_INSERT_SEARCHED 
									| SQL_IS_SELECT_INTO;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_INTEGRITY:
		retValue.u.strPtr = cNo;
		break;
	case SQL_KEYSET_CURSOR_ATTRIBUTES1:	
	case SQL_KEYSET_CURSOR_ATTRIBUTES2:	
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;					
	case SQL_KEYWORDS:
		retValue.u.strPtr = cKeywords;
		break;
	case SQL_LIKE_ESCAPE_CLAUSE:
		retValue.u.strPtr = cYes;
		break;
	case SQL_LOCK_TYPES:							// 2.0
		retValue.u.u32Value = 0;					// Not supported
		retValue.dataType = SQL_IS_UINTEGER;
		break;	
	case SQL_MAX_ASYNC_CONCURRENT_STATEMENTS:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_MAX_BINARY_LITERAL_LEN:	
		retValue.u.u32Value = 2*4050;		// Must be SQL Version based
		retValue.dataType = SQL_IS_UINTEGER;
		break;	
	case SQL_MAX_CATALOG_NAME_LEN:		// renameed to SQL_MAX_QUALIFIER_NAME_LEN			
		//retValue.u.u16Value = 30;		// Must be SQL Version based
		retValue.u.u16Value = 128;		// 070815-1501 
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MAX_CHAR_LITERAL_LEN:					// Must be SQL Version based
		retValue.u.u32Value = 4050;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_MAX_COLUMN_NAME_LEN:					// Must be SQL Version based
		retValue.u.u16Value = 128;				
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MAX_COLUMNS_IN_GROUP_BY:
	case SQL_MAX_COLUMNS_IN_INDEX:
	case SQL_MAX_COLUMNS_IN_ORDER_BY:
	case SQL_MAX_COLUMNS_IN_SELECT:
	case SQL_MAX_COLUMNS_IN_TABLE:
		retValue.u.u16Value = 0;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MAX_CONCURRENT_ACTIVITIES:
		retValue.u.u16Value = 0;			//Arvind: As per ODBC specs
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MAX_CURSOR_NAME_LEN:
		//retValue.u.u16Value = 30;			// Must be SQL Version based
		retValue.u.u16Value = 128;			
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MAX_DRIVER_CONNECTIONS:
		retValue.u.u16Value = 0;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MAX_IDENTIFIER_LEN:
		//retValue.u.u16Value = 30;			// Must be SQL Version based
		retValue.u.u16Value = 128;			
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MAX_INDEX_SIZE:
		retValue.u.u32Value = 4050;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_MAX_PROCEDURE_NAME_LEN: 
		retValue.u.u16Value = 128;			
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MAX_ROW_SIZE:
		retValue.u.u32Value = 4050;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
		retValue.u.strPtr = cYes;
		break;
	case SQL_MAX_SCHEMA_NAME_LEN:
		retValue.u.u16Value = 128;			// Must be SQL Version based
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MAX_STATEMENT_LEN:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_MAX_TABLE_NAME_LEN:
		retValue.u.u16Value = 128;			
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MAX_TABLES_IN_SELECT:
		retValue.u.u16Value = 0;			
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MAX_USER_NAME_LEN:
		retValue.u.u16Value = 32;			// Based on Safeguard alias name
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_MULT_RESULT_SETS:
		retValue.u.strPtr = cNo;
		break;
	case SQL_MULTIPLE_ACTIVE_TXN:
		retValue.u.strPtr = cNo;
		break;
	case SQL_NEED_LONG_DATA_LEN:
		retValue.u.strPtr = cNo;
		break;
	case SQL_NON_NULLABLE_COLUMNS:
		retValue.u.u16Value = SQL_NNC_NON_NULL;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_NULL_COLLATION:
		retValue.u.u16Value = SQL_NC_HIGH;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_NUMERIC_FUNCTIONS:
		retValue.u.u32Value = SQL_FN_NUM_ABS | SQL_FN_NUM_ACOS | SQL_FN_NUM_ASIN
				| SQL_FN_NUM_ATAN | SQL_FN_NUM_ATAN2
				| SQL_FN_NUM_CEILING | SQL_FN_NUM_COS | SQL_FN_NUM_DEGREES
				| SQL_FN_NUM_EXP | SQL_FN_NUM_FLOOR | SQL_FN_NUM_LOG
				| SQL_FN_NUM_LOG10 | SQL_FN_NUM_MOD | SQL_FN_NUM_PI | SQL_FN_NUM_POWER
				| SQL_FN_NUM_RADIANS | SQL_FN_NUM_RAND | SQL_FN_NUM_SIGN
				| SQL_FN_NUM_SIN | SQL_FN_NUM_SQRT | SQL_FN_NUM_TAN;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ODBC_API_CONFORMANCE:
		retValue.u.u16Value = SQL_OAC_LEVEL2;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_ODBC_INTERFACE_CONFORMANCE: // 3.0
		retValue.u.u32Value = SQL_OIC_CORE;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ODBC_SAG_CLI_CONFORMANCE:	// 1.0
		retValue.u.u16Value = SQL_OSCC_COMPLIANT;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_ODBC_SQL_CONFORMANCE:		// 1.0
		retValue.u.u16Value = SQL_OSC_CORE;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_ODBC_VER: // Implemented by DM
		break;
	case SQL_OJ_CAPABILITIES:
	case 65003:		// This is interim value used by DM when the ODBCVER >= 0x0201 && ODBCVER < 0x0300 
					// for SQL_OJ_CAPABILITIES
		retValue.u.u32Value = SQL_OJ_LEFT | SQL_OJ_RIGHT | SQL_OJ_FULL| SQL_OJ_NESTED | SQL_OJ_NOT_ORDERED | SQL_OJ_INNER |
				SQL_OJ_ALL_COMPARISON_OPS ;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_ORDER_BY_COLUMNS_IN_SELECT:
		retValue.u.strPtr = cNo;
		break;
	case SQL_OUTER_JOINS:
		retValue.u.strPtr = cYes;
		break;
	case SQL_PARAM_ARRAY_ROW_COUNTS:
		retValue.u.u32Value = SQL_PARC_NO_BATCH;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_PARAM_ARRAY_SELECTS:
		retValue.u.u32Value = SQL_PAS_NO_SELECT;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_POS_OPERATIONS:						// 2.0
		retValue.u.u32Value = 0;					// SQLSetPos unsupported
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_POSITIONED_STATEMENTS:					// 2.0
		retValue.u.u32Value = SQL_PS_POSITIONED_DELETE | SQL_PS_POSITIONED_UPDATE
					| SQL_PS_SELECT_FOR_UPDATE;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_PROCEDURE_TERM:
		retValue.u.strPtr = "procedure";
		break;
	case SQL_PROCEDURES:
		retValue.u.strPtr = cYes;
		break;
	case SQL_QUOTED_IDENTIFIER_CASE:
		retValue.u.u16Value = SQL_IC_SENSITIVE;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_ROW_UPDATES:
		retValue.u.strPtr = cNo;
		break;
	case SQL_SCHEMA_TERM:
		retValue.u.strPtr = "schema";
		break;
	case SQL_SCHEMA_USAGE:
		retValue.u.u32Value = SQL_SU_DML_STATEMENTS | SQL_SU_TABLE_DEFINITION | SQL_SU_PRIVILEGE_DEFINITION;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SCROLL_CONCURRENCY:		// 1.0
		retValue.u.u32Value = SQL_SCCO_LOCK;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SCROLL_OPTIONS:
		retValue.u.u32Value = SQL_SO_FORWARD_ONLY;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SEARCH_PATTERN_ESCAPE:
		retValue.u.strPtr = "\\";
		break;
	case SQL_SERVER_NAME:
		retValue.u.strPtr = m_SrvrIdentity;
		if (strlen(m_SrvrIdentity) % 2 != 0)
			strcat(retValue.u.strPtr, " ");
		break;
	case SQL_SPECIAL_CHARACTERS:
		retValue.u.strPtr = "$\\";
		break;
	case SQL_SQL_CONFORMANCE:
		retValue.u.u32Value = SQL_SC_SQL92_ENTRY;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SQL92_DATETIME_FUNCTIONS:
		retValue.u.u32Value = SQL_SDF_CURRENT_DATE | SQL_SDF_CURRENT_TIME 
				| SQL_SDF_CURRENT_TIMESTAMP;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SQL92_FOREIGN_KEY_DELETE_RULE:
	case SQL_SQL92_FOREIGN_KEY_UPDATE_RULE:
	case SQL_SQL92_GRANT:
		retValue.u.u32Value = 0;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SQL92_NUMERIC_VALUE_FUNCTIONS:
		retValue.u.u32Value = SQL_SNVF_CHAR_LENGTH | SQL_SNVF_CHARACTER_LENGTH
				| SQL_SNVF_EXTRACT | SQL_SNVF_OCTET_LENGTH | SQL_SNVF_POSITION;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SQL92_PREDICATES:
		retValue.u.u32Value = SQL_SP_BETWEEN | SQL_SP_COMPARISON | SQL_SP_EXISTS | SQL_SP_IN
				| SQL_SP_ISNOTNULL | SQL_SP_ISNULL | SQL_SP_LIKE | SQL_SP_MATCH_FULL
				| SQL_SP_MATCH_PARTIAL | SQL_SP_QUANTIFIED_COMPARISON;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SQL92_RELATIONAL_JOIN_OPERATORS:
		retValue.u.u32Value = SQL_SRJO_CROSS_JOIN | SQL_SRJO_FULL_OUTER_JOIN | SQL_SRJO_INNER_JOIN
				| SQL_SRJO_LEFT_OUTER_JOIN | SQL_SRJO_NATURAL_JOIN | SQL_SRJO_RIGHT_OUTER_JOIN
				| SQL_SRJO_UNION_JOIN | SQL_SRJO_CORRESPONDING_CLAUSE;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SQL92_REVOKE:				
	case SQL_SQL92_ROW_VALUE_CONSTRUCTOR:	
		retValue.u.u32Value = 0;	
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SQL92_STRING_FUNCTIONS:		
		retValue.u.u32Value = SQL_SSF_CONVERT | SQL_SSF_LOWER | SQL_SSF_UPPER | SQL_SSF_SUBSTRING
				| SQL_SSF_TRIM_BOTH | SQL_SSF_TRIM_LEADING | SQL_SSF_TRIM_TRAILING;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SQL92_VALUE_EXPRESSIONS:		
		retValue.u.u32Value = SQL_SVE_CASE | SQL_SVE_CAST;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_STANDARD_CLI_CONFORMANCE:		
		retValue.u.u32Value = SQL_SCC_XOPEN_CLI_VERSION1 | SQL_SCC_ISO92_CLI;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_STATIC_CURSOR_ATTRIBUTES1:		
	case SQL_STATIC_CURSOR_ATTRIBUTES2:
		retValue.u.u32Value = 0;				
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_STATIC_SENSITIVITY:		// 2.0
		retValue.u.u32Value = SQL_SS_ADDITIONS | SQL_SS_DELETIONS | SQL_SS_UPDATES;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_STRING_FUNCTIONS:
		retValue.u.u32Value = SQL_FN_STR_ASCII | SQL_FN_STR_CHAR | SQL_FN_STR_CONCAT 
					| SQL_FN_STR_INSERT | SQL_FN_STR_LCASE | SQL_FN_STR_LEFT 
					| SQL_FN_STR_LENGTH | SQL_FN_STR_LOCATE_2| SQL_FN_STR_LTRIM
					| SQL_FN_STR_REPEAT | SQL_FN_STR_REPLACE
					| SQL_FN_STR_RIGHT | SQL_FN_STR_RTRIM | SQL_FN_STR_SPACE
					| SQL_FN_STR_SUBSTRING | SQL_FN_STR_UCASE;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SUBQUERIES:
		retValue.u.u32Value = SQL_SQ_CORRELATED_SUBQUERIES | SQL_SQ_COMPARISON
					| SQL_SQ_EXISTS | SQL_SQ_IN | SQL_SQ_QUANTIFIED;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_SYSTEM_FUNCTIONS:
//		retValue.u.u32Value = SQL_FN_SYS_DBNAME | SQL_FN_SYS_USERNAME;
		retValue.u.u32Value = SQL_FN_SYS_USERNAME;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_TABLE_TERM:
		retValue.u.strPtr = "table";
		break;
	case SQL_TIMEDATE_ADD_INTERVALS:
		retValue.u.u32Value = SQL_FN_TSI_FRAC_SECOND | SQL_FN_TSI_SECOND
					| SQL_FN_TSI_MINUTE | SQL_FN_TSI_HOUR | SQL_FN_TSI_DAY
					| SQL_FN_TSI_WEEK | SQL_FN_TSI_MONTH | SQL_FN_TSI_YEAR;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_TIMEDATE_DIFF_INTERVALS:		
		retValue.u.u32Value = SQL_FN_TSI_FRAC_SECOND | SQL_FN_TSI_SECOND
					| SQL_FN_TSI_MINUTE | SQL_FN_TSI_HOUR | SQL_FN_TSI_DAY
					| SQL_FN_TSI_WEEK | SQL_FN_TSI_MONTH | SQL_FN_TSI_YEAR;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_TIMEDATE_FUNCTIONS:			
		retValue.u.u32Value = SQL_FN_TD_CURRENT_DATE | SQL_FN_TD_CURRENT_TIME 
				    | SQL_FN_TD_CURRENT_TIMESTAMP | SQL_FN_TD_DAYNAME 
				    | SQL_FN_TD_DAYOFMONTH | SQL_FN_TD_DAYOFWEEK 
				    | SQL_FN_TD_DAYOFYEAR | SQL_FN_TD_HOUR 
				    | SQL_FN_TD_MINUTE | SQL_FN_TD_MONTH 
				    | SQL_FN_TD_MONTHNAME | SQL_FN_TD_QUARTER 
				    | SQL_FN_TD_SECOND | SQL_FN_TD_WEEK 
				    | SQL_FN_TD_YEAR;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_TXN_CAPABLE:
		retValue.u.u16Value = SQL_TC_ALL;
		retValue.dataType = SQL_IS_USMALLINT;
		break;
	case SQL_TXN_ISOLATION_OPTION:
		retValue.u.u32Value = SQL_TXN_READ_UNCOMMITTED | SQL_TXN_READ_COMMITTED
					| SQL_TXN_REPEATABLE_READ  | SQL_TXN_SERIALIZABLE;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_UNION:
		retValue.u.u32Value = SQL_U_UNION;
		retValue.dataType = SQL_IS_UINTEGER;
		break;
	case SQL_USER_NAME:
		retValue.u.strPtr = m_UserName;
		break;
	case SQL_XOPEN_CLI_YEAR: 
		retValue.u.strPtr = "1995";
		break;
	default:
		setDiagRec(DRIVER_ERROR, IDS_HY_096);
		rc = SQL_ERROR;
		break;
	}

	if (rc == SQL_SUCCESS)
	{
		rc = returnAttrValue(TRUE, this, &retValue, InfoValuePtr, 
					BufferLength, &lStringLength);
		
		if (StringLengthPtr != NULL)
			*StringLengthPtr = (SQLSMALLINT)lStringLength;
	}
	return rc;
}

short CConnect::getTransactionNumber(void)
{
	CHANDLECOLLECT::iterator i;
	short count=0;
	for (i = m_StmtCollect.begin() ; i !=  m_StmtCollect.end() ; ++i)
		if(((CStmt *)(*i))->getStmtState() == STMT_FETCHED)
			count++;
	return count;
}

void CConnect::deleteValueList()
{ 
	CHANDLECOLLECT::iterator i;
	for (i = m_StmtCollect.begin() ; i !=  m_StmtCollect.end() ; ++i)
		((CStmt *)(*i))->deleteValueList();
}

SQLRETURN CConnect::NativeSql(
    SQLWCHAR 		  *InStatementTextW,
    SQLINTEGER         TextLength1,
    SQLWCHAR 		  *OutStatementTextW,
    SQLINTEGER         BufferLength,
    SQLINTEGER 		  *TextLength2Ptr)
{
	SQLRETURN		rc = SQL_SUCCESS;
	SQLINTEGER		InStrLen;
	
	if (TextLength1 == SQL_NTS)
		InStrLen = wcslen((const wchar_t *)InStatementTextW);
	else
		InStrLen = TextLength1;

	if (OutStatementTextW != NULL)
	{
		if (BufferLength == SQL_NTS || (BufferLength > 0 && InStrLen < BufferLength))
		{
			wcsncpy((wchar_t *)OutStatementTextW, (const wchar_t *)InStatementTextW, InStrLen);
			((wchar_t *)OutStatementTextW)[InStrLen] = L'\0';
		}
		else
		{
			wcsncpy((wchar_t *)OutStatementTextW, (const wchar_t *)InStatementTextW, BufferLength-1);
			((wchar_t *)OutStatementTextW)[BufferLength-1] = L'\0';
			setDiagRec(DRIVER_ERROR, IDS_01_004);
			rc = SQL_SUCCESS_WITH_INFO;
		}

	}
	if (TextLength2Ptr != NULL)
		*TextLength2Ptr = InStrLen;

	return rc;
}

DWORD CConnect::getSqlCharSet(long inSqlCharSet)
{
	switch(inSqlCharSet)
	{
	case SQLCHARSETCODE_ISO88591:
		return cnv_ISO88591;
	case SQLCHARSETCODE_SJIS:
		return cnv_SJIS;
	case SQLCHARSETCODE_KSC5601:
		return cnv_KSC;
	case SQLCHARSETCODE_BIG5:
		return cnv_BIG5;
	case SQLCHARSETCODE_GB2312:
		return cnv_GB2312;
	case SQLCHARSETCODE_GB18030:
		return cnv_GB18030;
	case SQLCHARSETCODE_UTF8:
		return cnv_UTF8;
	case SQLCHARSETCODE_UCS2:
		return cnv_UTF16;
	case SQLCHARSETCODE_UNKNOWN:
	case SQLCHARSETCODE_KANJI:
	default:
		return cnv_ISO88591;
	}
}

DWORD CConnect::getDrvrCharSet()
{
	DWORD langID;
	if (m_DSValue.m_DSCharSet == 0) // SYSTEM_DEFAULT
	{
		langID = GetSystemDefaultLangID();
		switch(langID)
		{
		case 0x0404: // Chinese (Taiwan Region)
			return cnv_BIG5;
		case 0x0804: // Chinese (PRC)
			return cnv_GBK;
		case 0x0409: // English (US)
			return cnv_ISO88591;
		case 0x0411: // Japanese
			return cnv_SJIS;
		case 0x0412: // Korean
			return cnv_KSC;
		default:
			return cnv_ISO88591;
		}
	}
	else
		return m_DSValue.m_DSCharSet;
}
//UTF8 character identification in the following code
//The most significant bit of a single-byte character is always 0. 
//The most significant bits of the first byte of a multi-byte sequence determine the length of the sequence. 
//These most significant bits are: 110 for two-byte sequences; 1110 for three-byte sequences, and so on. 
//The remaining bytes in a multi-byte sequence have 10 as their two most significant bits. 	
int CConnect::getUTF8CharLength(const char *inputChar, const int inputLength, const int maxLength)
{
	int length = 0;
	int numBytesInChar = 0;
	int idx = 0;
	unsigned char byte;

	while (inputChar[idx])
	{
		byte = inputChar[idx];
		if (byte & 0x80) //multibyte ?
		{    
			if ((byte & 0x40) && (byte & 0x20) && (byte & 0x10))
				numBytesInChar = 4;
			else if ((byte & 0x40) && (byte & 0x20) && !(byte & 0x10))
				numBytesInChar = 3;
			else if ((byte & 0x40) && !(byte & 0x20) && !(byte & 0x10))
				numBytesInChar = 2;
			if ((idx + numBytesInChar) > maxLength)
				break;
		}
		else
		{
			numBytesInChar = 1;
			if ((idx + numBytesInChar) > maxLength)
				break;
		}

		idx += numBytesInChar;
		length += numBytesInChar;
	}

	return length;
}

SQLRETURN CConnect::DoEncryption(SecPwd* &pSecPwd, ProcInfo SecInfo, USER_DESC_def &userDesc,char *AuthenticationNTS,CONNECTION_CONTEXT_def &inContext)
{
	short retCode=SQL_SUCCESS;

	char *dir;
	char *file;
	char *activefile;
	unsigned char *certificate_ts; 

	dir = NULL;
	file = NULL;
	activefile = NULL;
	certificate_ts = NULL;

	char *pwdKey=NULL;
	int	  pwdKeyLen=0;


	if (m_CertificateDir[0] != '\0')
		dir = m_CertificateDir;
	else if (m_DSValue.m_DSCertificateDir[0] != '\0' && strcmp(m_DSValue.m_DSCertificateDir, "SYSTEM_DEFAULT") != 0)
		dir = m_DSValue.m_DSCertificateDir;
	if (m_CertificateFile[0] != '\0')
		file = m_CertificateFile;
	else if (m_DSValue.m_DSCertificateFile[0] != '\0')
		file = m_DSValue.m_DSCertificateFile;
	if (m_CertificateFileActive[0] != '\0')
		activefile = m_CertificateFileActive;
	else if (m_DSValue.m_DSCertificateFileActive[0] != '\0')
		activefile = m_DSValue.m_DSCertificateFileActive;

	if (dir==NULL)
		TraceOut(TR_ODBC_API, "CertificateDir=NULL");
	else
		TraceOut(TR_ODBC_API, "CertificateDir=%s", dir);
	if (file==NULL)
		TraceOut(TR_ODBC_API, "CertificateFile=NULL");
	else
		TraceOut(TR_ODBC_API, "CertificateFile=%s", file);
	if (activefile==NULL)
		TraceOut(TR_ODBC_API, "ActiveCertificateFile=NULL");
	else
		TraceOut(TR_ODBC_API, "ActiveCertificateFile=%s", activefile);

	try 
	{
		if(pSecPwd == NULL)
			// CR6277. In SecPwd, it used stat() to check the directory,
			// stat() returns -1 when the directory contains trailing backslash.
			// Remove the trailing backslash from the directory.
			if(dir != NULL)
			{
				if(dir[strlen(dir)-1] == '\\')
				{
					dir[strlen(dir)-1] = '\0';
				}
			}
			pSecPwd = new SecPwd(dir, file, activefile, m_ClusterName);
	} 
	catch (SecurityException se) {
		retCode = se.getErrCode();
		setSecurityError(retCode, se.getSQLState(), se.getMsg());
	}

	if (retCode == SQL_SUCCESS)
	{
		try
		{
			pSecPwd->openCertificate();
		} 
		catch (SecurityException se) 
		{
			retCode = se.getErrCode();
			if (retCode == FILE_NOTFOUND) // certificate file not found, need to download
				inContext.inContextOptions1 = inContext.inContextOptions1 | INCONTEXT_OPT1_CERTIFICATE_TIMESTAMP;
			else
				setSecurityError(retCode, se.getSQLState(), se.getMsg());
		}
	}

	if (retCode == SQL_SUCCESS)
	{
		try
		{
			certificate_ts = pSecPwd->getCertExpDate();
			inContext.inContextOptions1 = inContext.inContextOptions1 | INCONTEXT_OPT1_CERTIFICATE_TIMESTAMP;
			inContext.connectOptions = (IDL_string)certificate_ts;
			pwdKeyLen = pSecPwd->getPwdEBufferLen();
			pwdKey = new char [pwdKeyLen]; // caller needs to free this
			pSecPwd->encryptPwd(AuthenticationNTS, strlen(AuthenticationNTS),
								 inContext.userRole, strlen(inContext.userRole),
								 (const char*)&m_SecInfo, sizeof(m_SecInfo),
								 pwdKey, &pwdKeyLen);
		} 
		catch (SecurityException se) {
			retCode = se.getErrCode();
			setSecurityError(retCode, se.getSQLState(), se.getMsg());
		}
	}

	if (retCode == SQL_SUCCESS)
	{
		userDesc.password._length = pwdKeyLen;
		userDesc.password._buffer = (IDL_octet *)pwdKey;
	}
	else
	{
		userDesc.userName = NULL;
		userDesc.password._length = 0;
		userDesc.password._buffer = NULL;
	}

	return retCode;

} /* DoEncryption() */

void CConnect::setSecurityError(int error, char* sqlState, char* errorMsg)
{
	setDiagRec(SQLMX_ERROR, IDS_SQL_ERROR, error, errorMsg, sqlState);
	return;
}