bool CODBC_RPCCmd::x_AssignParams(string& cmd, string& q_exec, string& q_select,
CMemPot& bind_guard, SQLLEN* indicator)
{
char p_nm[16];
// check if we do have a named parameters (first named - all named)
bool param_named = !GetBindParamsImpl().GetParamName(0).empty();
for (unsigned int n = 0; n < GetBindParamsImpl().NofParams(); n++) {
if(GetBindParamsImpl().GetParamStatus(n) == 0) continue;
const string& name = GetBindParamsImpl().GetParamName(n);
CDB_Object& param = *GetBindParamsImpl().GetParam(n);
if (!x_BindParam_ODBC(param, bind_guard, indicator, n)) {
return false;
}
q_exec += n ? ',':' ';
const string type = Type2String(param);
if(!param_named) {
sprintf(p_nm, "@pR%d", n);
q_exec += p_nm;
cmd += "declare ";
cmd += p_nm;
cmd += ' ';
cmd += type;
cmd += ";select ";
cmd += p_nm;
cmd += " = ?;";
}
else {
q_exec += name+'='+name;
cmd += "declare " + name + ' ' + type + ";select " + name + " = ?;";
}
if(param.IsNULL()) {
indicator[n] = SQL_NULL_DATA;
}
if ((GetBindParamsImpl().GetParamStatus(n) & impl::CDB_Params::fOutput) != 0) {
q_exec += " output";
const char* p_name = param_named? name.c_str() : p_nm;
if(!q_select.empty()) q_select += ',';
q_select.append(p_name+1);
q_select += '=';
q_select += p_name;
}
}
GetBindParamsImpl().LockBinding();
return true;
}
/****************************************************************************
* *
* FUNCTION : CreateXactionWindow() *
* *
* PURPOSE : Creates a transaction window for the given transaction *
* under the given conversation window. *
* *
* RETURNS : TRUE - If successful. *
* FALSE - otherwise. *
* *
****************************************************************************/
HWND CreateXactionWindow(
HWND hwndMDI,
XACT *pxact)
{
PSTR pszFmt, pszItem;
PSTR pData;
HWND hwnd;
pszItem = GetHSZName(pxact->hszItem);
pszFmt = GetFormatName(pxact->wFmt);
pData = GetTextData(pxact->hDdeData);
/*
* Útype/optsÄÄÄÄÄÄÄ ITEM ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄretÄ¿ GWW_WUSER=pxact
* ³ ³
* ³ ³
* ³ ³
* ³ ³
* ³ DATA ³
* ³ ³
* ³ ³
* ³ ³
* ³ ³
* Àstate/errorÄÄÄÄÄ FORMAT ÄÄÄÄÄÄÄÄÄÄResultÄÙ
*/
hwnd = CreateInfoCtrl((LPSTR)pData,
(int)SendMessage(hwndMDI, UM_GETNEXTCHILDX, 0, 0L),
(int)SendMessage(hwndMDI, UM_GETNEXTCHILDY, 0, 0L),
200, 100, hwndMDI, hInst,
Type2String(pxact->wType, pxact->fsOptions), pszItem, NULL,
"Starting", (LPSTR)pszFmt, NULL,
ICSTY_SHOWFOCUS, 0, (DWORD)(LPSTR)pxact);
MyFree(pszItem);
MyFree(pszFmt);
MyFree(pData);
return(hwnd);
}
bool CReader::Connect()
{
if (m_poCard != NULL)
Disconnect(DISCONNECT_LEAVE_CARD);
m_poCard = CardConnect(m_csReader, m_poContext, NULL, m_oCardPluginLib);
if (m_poCard != NULL)
{
m_oPKCS15.SetCard(m_poCard);
if (m_oPinpad->UsePinpad())
{
MWLOG(LEV_DEBUG, MOD_CAL, L"Using Pinpad reader.");
m_poCard->setPinpadHandler(m_oPinpad->getPinpadHandler(m_poCard->m_hCard));
}
else
MWLOG(LEV_DEBUG, MOD_CAL, L"Using non-pinpad reader.");
MWLOG(LEV_INFO, MOD_CAL, L" Connected to %ls card in reader %ls",
Type2String(m_poCard->GetType()), m_wsReader.c_str());
}
return m_poCard != NULL;
}
/****************************************************************************
* *
* FUNCTION : ProcessTransaction() *
* *
* PURPOSE : Processes synchronous transactions entirely and starts *
* async transactions. Transaction attempts result in a *
* transaction window being created which displays the state *
* or results of the transaction. (the callback function *
* updates these windows as it gets calls) Transaction *
* windows stay around until abandoned by the user or until *
* the conversation is disconnected. Advise Data and Advise *
* Stop transactions are special. We don't create a new *
* window if the associated advise start transaction window *
* can be found. *
* *
* RETURNS : TRUE - If successful. *
* FALSE - otherwise. *
* *
****************************************************************************/
BOOL ProcessTransaction(
XACT *pxact)
{
CONVINFO ci;
HWND hwndInfoCtrl = 0;
/* create transaction window to show we tried (except in ADVSTOP case) */
pxact = (XACT *)memcpy(MyAlloc(sizeof(XACT)), (PSTR)pxact, sizeof(XACT));
ci.cb = sizeof(CONVINFO);
DdeQueryConvInfo(pxact->hConv, (DWORD)QID_SYNC, &ci); // ci.hUser==hConv
if (pxact->wType == XTYP_ADVSTOP) {
hwndInfoCtrl = FindAdviseChild((HWND)ci.hUser, pxact->hszItem,
pxact->wFmt);
if (hwndInfoCtrl) {
SendMessage(hwndInfoCtrl, ICM_SETSTRING, ICSID_UL,
(DWORD)(LPSTR)Type2String(pxact->wType, pxact->fsOptions));
DdeFreeStringHandle(idInst, pxact->hszItem);
}
}
/*
* If we still need to create a transaction window, do so here.
*/
if (!hwndInfoCtrl) {
hwndInfoCtrl = CreateXactionWindow((HWND)ci.hUser, pxact);
if (!hwndInfoCtrl) {
MyFree(pxact);
return 0;
}
SetFocus(hwndInfoCtrl);
}
/*
* Disable callbacks for this conversation now if the XOPT_DISABLEFIRST
* option is set. This tests disabling asynchronous transactions
* before they are completed.
*/
if (pxact->fsOptions & XOPT_DISABLEFIRST)
DdeEnableCallback(idInst, pxact->hConv, EC_DISABLE);
/*
* Adjust the timeout for asynchronous transactions.
*/
if (pxact->fsOptions & XOPT_ASYNC)
pxact->ulTimeout = (DWORD)TIMEOUT_ASYNC;
/*
* start transaction with DDEML here
*/
pxact->ret = DdeClientTransaction((LPBYTE)pxact->hDdeData, (DWORD)-1,
pxact->hConv, pxact->hszItem, pxact->wFmt,
pxact->wType,
pxact->ulTimeout, (LPDWORD)&pxact->Result);
/*
* show return value in transaction window
*/
wsprintf(szT, "ret=%lx", pxact->ret);
SendMessage(hwndInfoCtrl, ICM_SETSTRING, ICSID_UR, (DWORD)(LPSTR)szT);
/*
* show result or ID value in transaction window
*/
wsprintf(szT, pxact->fsOptions & XOPT_ASYNC ? "ID=%ld" :
"result=0x%lx", pxact->Result);
SendMessage(hwndInfoCtrl, ICM_SETSTRING, ICSID_LR, (DWORD)(LPSTR)szT);
if ((pxact->fsOptions & XOPT_ASYNC) && pxact->ret) {
/*
* asynchronous successful start - link transaction to window.
*/
DdeSetUserHandle(pxact->hConv, pxact->Result, (DWORD)hwndInfoCtrl);
/*
* Abandon started async transaction after initiated if
* XOPT_ABANDONAFTERSTART is chosen. This tests the mid-transaction
* abandoning code.
*/
if (pxact->fsOptions & XOPT_ABANDONAFTERSTART)
DdeAbandonTransaction(idInst, pxact->hConv, pxact->Result);
/*
* show actual status
*/
ci.cb = sizeof(CONVINFO);
DdeQueryConvInfo(pxact->hConv, pxact->Result, &ci);
SendMessage(hwndInfoCtrl, ICM_SETSTRING, ICSID_LL,
(DWORD)(LPSTR)State2String(ci.wConvst));
} else {
/*
* Synchronous transactions are completed already so pass on to
* CompleteTransaction right away.
*/
CompleteTransaction(hwndInfoCtrl, pxact);
}
return TRUE;
}
/****************************************************************************
* *
* FUNCTION : DdeCallback() *
* *
* PURPOSE : This handles all callbacks from the DDEML. This handles *
* updating of the associated conversation and any special *
* testing cases such as blocking callbacks etc. *
* *
* For the most part, clients only handle advise data and *
* asynchronous transaction completion here. *
* *
* RETURNS : Results vary depending on transaction type. *
* *
****************************************************************************/
HDDEDATA EXPENTRY DdeCallback(
WORD wType,
WORD wFmt,
HCONV hConv,
HSZ hsz1,
HSZ hsz2,
HDDEDATA hData,
DWORD lData1,
DWORD lData2)
{
HWND hwnd;
CONVINFO ci;
XACT *pxact;
if (hConv) {
/*
* update conversation status if it changed.
*/
MYCONVINFO *pmci;
ci.cb = sizeof(CONVINFO);
if (!DdeQueryConvInfo(hConv,(DWORD) QID_SYNC, &ci) || (!IsWindow((HWND)ci.hUser))) {
/*
* This conversation does not yet have a corresponding MDI window
* or is disconnected.
*/
return 0;
}
if (pmci = (MYCONVINFO *)GetWindowWord((HWND)ci.hUser, 0)) {
if (pmci->ci.wStatus != ci.wStatus ||
pmci->ci.wConvst != ci.wConvst ||
pmci->ci.wLastError != ci.wLastError) {
/*
* Things have changed, updated the conversation window.
*/
InvalidateRect((HWND)ci.hUser, NULL, TRUE);
}
if (ci.wConvst & ST_INLIST) {
/*
* update the associated list window (if any) as well.
*/
if (hwnd = FindListWindow(ci.hConvList))
InvalidateRect(hwnd, NULL, TRUE);
}
}
}
/*
* handle special block on next callback option here. This demonstrates
* the CBR_BLOCK feature.
*/
if (fBlockNextCB && !(wType & XTYPF_NOBLOCK)) {
fBlockNextCB = FALSE;
return(CBR_BLOCK);
}
/*
* handle special termination here. This demonstrates that at any time
* a client can drop a conversation.
*/
if (fTermNextCB && hConv && wType != XTYP_DISCONNECT) {
fTermNextCB = FALSE;
MyDisconnect(hConv);
return(0);
}
/*
* Now we begin sort out what to do.
*/
switch (wType) {
case XTYP_REGISTER:
case XTYP_UNREGISTER:
/*
* This is where the client would insert code to keep track of
* what servers are available. This could cause the initiation
* of some conversations.
*/
break;
case XTYP_DISCONNECT:
if (fAutoReconnect) {
/*
* attempt a reconnection
*/
if (hConv = DdeReconnect(hConv)) {
AddConv(ci.hszServiceReq, ci.hszTopic, hConv, FALSE);
return 0;
}
}
/*
* update conv window to show its new state.
*/
SendMessage((HWND)ci.hUser, UM_DISCONNECTED, 0, 0);
return 0;
break;
case XTYP_ADVDATA:
/*
* data from an active advise loop (from a server)
*/
Delay(wDelay);
hwnd = FindAdviseChild((HWND)ci.hUser, hsz2, wFmt);
if (!IsWindow(hwnd)) {
PSTR pszItem, pszFmt;
/*
* AdviseStart window is gone, make a new one.
*/
pxact = (XACT *)MyAlloc(sizeof(XACT));
pxact->wType = wType;
pxact->hConv = hConv;
pxact->wFmt = wFmt;
pxact->hszItem = hsz2;
DdeKeepStringHandle(idInst, hsz2);
pszItem = GetHSZName(hsz2);
pszFmt = GetFormatName(wFmt);
hwnd = CreateInfoCtrl(NULL,
(int)SendMessage((HWND)ci.hUser, UM_GETNEXTCHILDX, 0, 0L),
(int)SendMessage((HWND)ci.hUser, UM_GETNEXTCHILDY, 0, 0L),
200, 100,
(HWND)ci.hUser, hInst,
Type2String(wType, 0), (LPSTR)pszItem, NULL,
NULL, (LPSTR)pszFmt, NULL,
ICSTY_SHOWFOCUS, 0, (DWORD)(LPSTR)pxact);
MyFree(pszFmt);
MyFree(pszItem);
if (!IsWindow(hwnd))
return(DDE_FNOTPROCESSED);
}
if (!hData) {
/*
* XTYPF_NODATA case - request the info. (we do this synchronously
* for simplicity)
*/
hData = DdeClientTransaction(NULL, 0L, hConv, hsz2, wFmt,
XTYP_REQUEST, DefTimeout, NULL);
}
if (hData) {
PSTR pData;
/*
* Show incomming data on corresponding transaction window.
*/
pData = GetTextData(hData);
SendMessage(hwnd, ICM_SETSTRING, ICSID_CENTER, (DWORD)(LPSTR)pData);
MyFree(pData);
DdeFreeDataHandle(hData);
}
SendMessage(hwnd, ICM_SETSTRING, ICSID_LL, (DWORD)(LPSTR)"Advised");
return(DDE_FACK);
break;
case XTYP_XACT_COMPLETE:
/*
* An asynchronous transaction has completed. Show the results.
*
* ...unless the XOPT_BLOCKRESULT is chosen.
*/
ci.cb = sizeof(CONVINFO);
if (DdeQueryConvInfo(hConv, lData1, &ci) &&
IsWindow((HWND)ci.hUser) &&
(pxact = (XACT *)GetWindowWord((HWND)ci.hUser, GWW_WUSER))) {
if (pxact->fsOptions & XOPT_BLOCKRESULT) {
pxact->fsOptions &= ~XOPT_BLOCKRESULT;
return(CBR_BLOCK);
}
pxact->Result = lData2;
pxact->ret = hData;
CompleteTransaction((HWND)ci.hUser, pxact);
}
break;
}
}
