RETCODE SQL_API
SQLConnectW(HDBC ConnectionHandle,
SQLWCHAR *ServerName, SQLSMALLINT NameLength1,
SQLWCHAR *UserName, SQLSMALLINT NameLength2,
SQLWCHAR *Authentication, SQLSMALLINT NameLength3)
{
CSTR func = "SQLConnectW";
char *svName, *usName, *auth;
SQLLEN nmlen1, nmlen2, nmlen3;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
mylog("[%s]", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
CC_set_in_unicode_driver(conn);
svName = ucs2_to_utf8(ServerName, NameLength1, &nmlen1, FALSE);
usName = ucs2_to_utf8(UserName, NameLength2, &nmlen2, FALSE);
auth = ucs2_to_utf8(Authentication, NameLength3, &nmlen3, FALSE);
ret = PGAPI_Connect(ConnectionHandle,
(SQLCHAR *) svName, (SQLSMALLINT) nmlen1,
(SQLCHAR *) usName, (SQLSMALLINT) nmlen2,
(SQLCHAR *) auth, (SQLSMALLINT) nmlen3);
LEAVE_CONN_CS(conn);
if (svName)
free(svName);
if (usName)
free(usName);
if (auth)
free(auth);
return ret;
}
RETCODE SQL_API SQLGetInfoW(HDBC ConnectionHandle,
SQLUSMALLINT InfoType, PTR InfoValue,
SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
{
CSTR func = "SQLGetInfoW";
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
RETCODE ret;
ENTER_CONN_CS(conn);
CC_set_in_unicode_driver(conn);
CC_clear_error(conn);
#if (ODBCVER >= 0x0300)
mylog("[%s(30)]", func);
if ((ret = PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue,
BufferLength, StringLength)) == SQL_ERROR)
{
if (conn->driver_version >= 0x0300)
{
CC_clear_error(conn);
ret = PGAPI_GetInfo30(ConnectionHandle, InfoType, InfoValue,
BufferLength, StringLength);
}
}
if (SQL_ERROR == ret)
CC_log_error("SQLGetInfoW(30)", "", conn);
#else
mylog("[%s]", func);
ret = PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue,
BufferLength, StringLength);
if (SQL_ERROR == ret)
CC_log_error("SQLGetInfoW", "", conn);
#endif
LEAVE_CONN_CS(conn);
return ret;
}
RETCODE SQL_API
SQLNativeSqlW(HDBC hdbc,
SQLWCHAR *szSqlStrIn,
SQLINTEGER cbSqlStrIn,
SQLWCHAR *szSqlStr,
SQLINTEGER cbSqlStrMax,
SQLINTEGER *pcbSqlStr)
{
CSTR func = "SQLNativeSqlW";
RETCODE ret;
char *szIn, *szOut = NULL, *szOutt = NULL;
SQLLEN slen;
SQLINTEGER buflen, olen;
ConnectionClass *conn = (ConnectionClass *) hdbc;
mylog("[%s}", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
CC_set_in_unicode_driver(conn);
szIn = ucs2_to_utf8(szSqlStrIn, cbSqlStrIn, &slen, FALSE);
buflen = 3 * cbSqlStrMax;
if (buflen > 0)
szOutt = malloc(buflen);
for (;; buflen = olen + 1, szOutt = realloc(szOut, buflen))
{
if (!szOutt)
{
CC_set_error(conn, CONN_NO_MEMORY_ERROR, "Could not allocate memory for output buffer", func);
ret = SQL_ERROR;
break;
}
szOut = szOutt;
ret = PGAPI_NativeSql(hdbc, (SQLCHAR *) szIn, (SQLINTEGER) slen,
(SQLCHAR *) szOut, buflen, &olen);
if (SQL_SUCCESS_WITH_INFO != ret || olen < buflen)
break;
}
if (szIn)
free(szIn);
if (SQL_SUCCEEDED(ret))
{
SQLLEN szcount = olen;
if (olen < buflen)
szcount = utf8_to_ucs2(szOut, olen, szSqlStr, cbSqlStrMax);
if (SQL_SUCCESS == ret && szcount > cbSqlStrMax)
{
ConnectionClass *conn = (ConnectionClass *) hdbc;
ret = SQL_SUCCESS_WITH_INFO;
CC_set_error(conn, CONN_TRUNCATED, "Sql string too large", func);
}
if (pcbSqlStr)
*pcbSqlStr = (SQLINTEGER) szcount;
}
LEAVE_CONN_CS(conn);
free(szOut);
return ret;
}
RETCODE SQL_API SQLGetConnectOptionW(HDBC ConnectionHandle,
SQLUSMALLINT Option, PTR Value)
{
mylog("[SQLGetConnectOptionW]");
CC_set_in_unicode_driver((ConnectionClass *) ConnectionHandle);
return PGAPI_GetConnectOption(ConnectionHandle, Option, Value, NULL, 64);
}
RETCODE SQL_API SQLSetConnectOptionW(HDBC ConnectionHandle,
SQLUSMALLINT Option, SQLUINTEGER Value)
{
mylog("[SQLSetConnectionOptionW]");
if (!ConnectionHandle) return SQL_ERROR;
CC_set_in_unicode_driver((ConnectionClass *) ConnectionHandle);
return PGAPI_SetConnectOption(ConnectionHandle, Option, Value);
}
RETCODE SQL_API SQLSetConnectAttrW(HDBC hdbc,
SQLINTEGER fAttribute,
PTR rgbValue,
SQLINTEGER cbValue)
{
CSTR func = "SQLSetConnectAttrW";
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
mylog("[%s]", func);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
CC_set_in_unicode_driver(conn);
ret = PGAPI_SetConnectAttr(hdbc, fAttribute, rgbValue,
cbValue);
LEAVE_CONN_CS(conn);
return ret;
}
RETCODE SQL_API
SQLBrowseConnectW(HDBC hdbc,
SQLWCHAR *szConnStrIn,
SQLSMALLINT cbConnStrIn,
SQLWCHAR *szConnStrOut,
SQLSMALLINT cbConnStrOutMax,
SQLSMALLINT *pcbConnStrOut)
{
CSTR func = "SQLBrowseConnectW";
char *szIn, *szOut;
SQLLEN inlen;
SQLUSMALLINT obuflen;
SQLSMALLINT olen;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
mylog("[%s]", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
CC_set_in_unicode_driver(conn);
szIn = ucs2_to_utf8(szConnStrIn, cbConnStrIn, &inlen, FALSE);
obuflen = cbConnStrOutMax + 1;
szOut = malloc(obuflen);
if (szOut)
ret = PGAPI_BrowseConnect(hdbc, (SQLCHAR *) szIn, (SQLSMALLINT) inlen,
(SQLCHAR *) szOut, cbConnStrOutMax, &olen);
else
{
CC_set_error(conn, CONN_NO_MEMORY_ERROR, "Could not allocate memory for output buffer", func);
ret = SQL_ERROR;
}
LEAVE_CONN_CS(conn);
if (ret != SQL_ERROR)
{
SQLLEN outlen = utf8_to_ucs2(szOut, olen, szConnStrOut, cbConnStrOutMax);
if (pcbConnStrOut)
*pcbConnStrOut = (SQLSMALLINT) outlen;
}
free(szOut);
if (szIn)
free(szIn);
return ret;
}
RETCODE SQL_API
SQLGetInfoW(HDBC ConnectionHandle,
SQLUSMALLINT InfoType, PTR InfoValue,
SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
{
CSTR func = "SQLGetInfoW";
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
RETCODE ret;
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_set_in_unicode_driver(conn);
CC_clear_error(conn);
mylog("[%s]", func);
if ((ret = PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue,
BufferLength, StringLength)) == SQL_ERROR)
CC_log_error("SQLGetInfoW", "", conn);
LEAVE_CONN_CS(conn);
return ret;
}
RETCODE SQL_API SQLBrowseConnectW(
HDBC hdbc,
SQLWCHAR *szConnStrIn,
SQLSMALLINT cbConnStrIn,
SQLWCHAR *szConnStrOut,
SQLSMALLINT cbConnStrOutMax,
SQLSMALLINT *pcbConnStrOut)
{
CSTR func = "SQLBrowseConnectW";
char *szIn, *szOut;
SQLLEN inlen;
SQLUSMALLINT obuflen;
SQLSMALLINT olen;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
mylog("[%s]", func);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
CC_set_in_unicode_driver(conn);
szIn = ucs2_to_utf8(szConnStrIn, cbConnStrIn, &inlen, FALSE);
obuflen = cbConnStrOutMax + 1;
szOut = malloc(obuflen);
ret = PGAPI_BrowseConnect(hdbc, szIn, (SQLSMALLINT) inlen,
szOut, cbConnStrOutMax, &olen);
LEAVE_CONN_CS(conn);
if (ret != SQL_ERROR)
{
SQLLEN outlen = utf8_to_ucs2(szOut, olen, szConnStrOut, cbConnStrOutMax);
if (pcbConnStrOut)
*pcbConnStrOut = (SQLSMALLINT) outlen;
}
free(szOut);
if (szIn)
free(szIn);
return ret;
}
RETCODE SQL_API
SQLDriverConnectW(HDBC hdbc,
HWND hwnd,
SQLWCHAR *szConnStrIn,
SQLSMALLINT cbConnStrIn,
SQLWCHAR *szConnStrOut,
SQLSMALLINT cbConnStrOutMax,
SQLSMALLINT *pcbConnStrOut,
SQLUSMALLINT fDriverCompletion)
{
CSTR func = "SQLDriverConnectW";
char *szIn, *szOut = NULL;
SQLSMALLINT maxlen, obuflen = 0;
SQLLEN inlen;
SQLSMALLINT olen, *pCSO;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
mylog("[%s]", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
CC_set_in_unicode_driver(conn);
szIn = ucs2_to_utf8(szConnStrIn, cbConnStrIn, &inlen, FALSE);
maxlen = cbConnStrOutMax;
pCSO = NULL;
olen = 0;
if (maxlen > 0)
{
obuflen = maxlen + 1;
szOut = malloc(obuflen);
if (!szOut)
{
CC_set_error(conn, CONN_NO_MEMORY_ERROR, "Could not allocate memory for output buffer", func);
ret = SQL_ERROR;
goto cleanup;
}
pCSO = &olen;
}
else if (pcbConnStrOut)
pCSO = &olen;
ret = PGAPI_DriverConnect(hdbc, hwnd,
(SQLCHAR *) szIn, (SQLSMALLINT) inlen,
(SQLCHAR *) szOut, maxlen,
pCSO, fDriverCompletion);
if (ret != SQL_ERROR && NULL != pCSO)
{
SQLLEN outlen = olen;
if (olen < obuflen)
outlen = utf8_to_ucs2(szOut, olen, szConnStrOut, cbConnStrOutMax);
else
utf8_to_ucs2(szOut, maxlen, szConnStrOut, cbConnStrOutMax);
if (outlen >= cbConnStrOutMax && NULL != szConnStrOut && NULL != pcbConnStrOut)
{
inolog("cbConnstrOutMax=%d pcb=%p\n", cbConnStrOutMax, pcbConnStrOut);
if (SQL_SUCCESS == ret)
{
CC_set_error(conn, CONN_TRUNCATED, "the ConnStrOut is too small", func);
ret = SQL_SUCCESS_WITH_INFO;
}
}
if (pcbConnStrOut)
*pcbConnStrOut = (SQLSMALLINT) outlen;
}
cleanup:
LEAVE_CONN_CS(conn);
if (szOut)
free(szOut);
if (szIn)
free(szIn);
return ret;
}
/*-------
* ConfigDlgProc
* Description: Manage add data source name dialog
* Input : hdlg --- Dialog window handle
* wMsg --- Message
* wParam - Message parameter
* lParam - Message parameter
* Output : TRUE if message processed, FALSE otherwise
*-------
*/
LRESULT CALLBACK
ConfigDlgProc(HWND hdlg,
UINT wMsg,
WPARAM wParam,
LPARAM lParam)
{
LPSETUPDLG lpsetupdlg;
ConnInfo *ci;
DWORD cmd;
char strbuf[64];
switch (wMsg)
{
/* Initialize the dialog */
case WM_INITDIALOG:
lpsetupdlg = (LPSETUPDLG) lParam;
ci = &lpsetupdlg->ci;
/* Hide the driver connect message */
ShowWindow(GetDlgItem(hdlg, DRV_MSG_LABEL), SW_HIDE);
LoadString(s_hModule, IDS_ADVANCE_SAVE, strbuf, sizeof(strbuf));
SetWindowText(GetDlgItem(hdlg, IDOK), strbuf);
SetWindowLongPtr(hdlg, DWLP_USER, lParam);
CenterDialog(hdlg); /* Center dialog */
/*
* NOTE: Values supplied in the attribute string will always
*/
/* override settings in ODBC.INI */
copy_globals(&ci->drivers, &globals);
/* Get the rest of the common attributes */
getDSNinfo(ci, CONN_DONT_OVERWRITE);
/* Fill in any defaults */
getDSNdefaults(ci);
/* Initialize dialog fields */
SetDlgStuff(hdlg, ci);
if (lpsetupdlg->fNewDSN || !ci->dsn[0])
ShowWindow(GetDlgItem(hdlg, IDC_MANAGEDSN), SW_HIDE);
if (lpsetupdlg->fDefault)
{
EnableWindow(GetDlgItem(hdlg, IDC_DSNAME), FALSE);
EnableWindow(GetDlgItem(hdlg, IDC_DSNAMETEXT), FALSE);
}
else
SendDlgItemMessage(hdlg, IDC_DSNAME,
EM_LIMITTEXT, (WPARAM) (MAXDSNAME - 1), 0L);
SendDlgItemMessage(hdlg, IDC_DESC,
EM_LIMITTEXT, (WPARAM) (MAXDESC - 1), 0L);
return TRUE; /* Focus was not set */
/* Process buttons */
case WM_COMMAND:
switch (cmd = GET_WM_COMMAND_ID(wParam, lParam))
{
/*
* Ensure the OK button is enabled only when a data
* source name
*/
/* is entered */
case IDC_DSNAME:
if (GET_WM_COMMAND_CMD(wParam, lParam) == EN_CHANGE)
{
char szItem[MAXDSNAME]; /* Edit control text */
/* Enable/disable the OK button */
EnableWindow(GetDlgItem(hdlg, IDOK),
GetDlgItemText(hdlg, IDC_DSNAME,
szItem, sizeof(szItem)));
return TRUE;
}
break;
/* Accept results */
case IDOK:
case IDAPPLY:
lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
/* Retrieve dialog values */
if (!lpsetupdlg->fDefault)
GetDlgItemText(hdlg, IDC_DSNAME,
lpsetupdlg->ci.dsn,
sizeof(lpsetupdlg->ci.dsn));
/* Get Dialog Values */
GetDlgStuff(hdlg, &lpsetupdlg->ci);
/* Update ODBC.INI */
SetDSNAttributes(hdlg, lpsetupdlg, NULL);
if (IDAPPLY == cmd)
break;
/* Return to caller */
case IDCANCEL:
EndDialog(hdlg, wParam);
return TRUE;
case IDC_TEST:
{
lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
if (NULL != lpsetupdlg)
{
EnvironmentClass *env = EN_Constructor();
ConnectionClass *conn = NULL;
char szMsg[SQL_MAX_MESSAGE_LENGTH];
/* Get Dialog Values */
GetDlgStuff(hdlg, &lpsetupdlg->ci);
if (env)
conn = CC_Constructor();
if (conn)
{
char *emsg, *allocstr = NULL;
#ifdef UNICODE_SUPPORT
int tlen;
SQLWCHAR *wermsg = NULL;
SQLULEN ulen;
#endif /* UNICODE_SUPPORT */
int errnum;
EN_add_connection(env, conn);
CC_copy_conninfo(&conn->connInfo, &lpsetupdlg->ci);
CC_initialize_pg_version(conn);
logs_on_off(1, conn->connInfo.drivers.debug, conn->connInfo.drivers.commlog);
#ifdef UNICODE_SUPPORT
CC_set_in_unicode_driver(conn);
#endif /* UNICODE_SUPPORT */
if (CC_connect(conn, AUTH_REQ_OK, NULL) > 0)
{
if (CC_get_errornumber(conn) != 0)
{
CC_get_error(conn, &errnum, &emsg);
snprintf(szMsg, sizeof(szMsg), "Warning: %s", emsg);
}
else
strncpy_null(szMsg, "Connection successful", sizeof(szMsg));
emsg = szMsg;
}
else
{
CC_get_error(conn, &errnum, &emsg);
}
#ifdef UNICODE_SUPPORT
tlen = strlen(emsg);
wermsg = (SQLWCHAR *) malloc(sizeof(SQLWCHAR) * (tlen + 1));
ulen = utf8_to_ucs2_lf1(emsg, SQL_NTS, FALSE, wermsg, tlen + 1);
if (ulen != (SQLULEN) -1)
{
allocstr = malloc(4 * tlen + 1);
tlen = (SQLSMALLINT) wstrtomsg(NULL, wermsg,
(int) tlen, allocstr, (int) 4 * tlen + 1);
emsg = allocstr;
}
if (NULL != wermsg)
free(wermsg);
#endif /* UNICODE_SUPPORT */
MessageBox(lpsetupdlg->hwndParent, emsg, "Connection Test", MB_ICONEXCLAMATION | MB_OK);
logs_on_off(-1, conn->connInfo.drivers.debug, conn->connInfo.drivers.commlog);
EN_remove_connection(env, conn);
CC_Destructor(conn);
if (NULL != allocstr)
free(allocstr);
}
if (env)
EN_Destructor(env);
return TRUE;
}
break;
}
case IDC_DATASOURCE:
lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
DialogBoxParam(s_hModule, MAKEINTRESOURCE(DLG_OPTIONS_DRV),
hdlg, ds_options1Proc, (LPARAM) &lpsetupdlg->ci);
return TRUE;
case IDC_DRIVER:
lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
DialogBoxParam(s_hModule, MAKEINTRESOURCE(DLG_OPTIONS_GLOBAL),
hdlg, global_optionsProc, (LPARAM) &lpsetupdlg->ci);
return TRUE;
case IDC_MANAGEDSN:
lpsetupdlg = (LPSETUPDLG) GetWindowLongPtr(hdlg, DWLP_USER);
if (DialogBoxParam(s_hModule, MAKEINTRESOURCE(DLG_DRIVER_CHANGE),
hdlg, manage_dsnProc,
(LPARAM) lpsetupdlg) > 0)
EndDialog(hdlg, 0);
return TRUE;
}
break;
case WM_CTLCOLORSTATIC:
if (lParam == (LPARAM)GetDlgItem(hdlg, IDC_NOTICE_USER))
{
HBRUSH hBrush = (HBRUSH)GetStockObject(LTGRAY_BRUSH);
SetTextColor((HDC)wParam, RGB(255, 0, 0));
return (long)hBrush;
}
break;
}
/* Message not processed */
return FALSE;
}
