void SQLFETCHPERF_swap(char* buffer)
{
short number_of_param = FetchPerf_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
DIALOGUE_ID_def *dialogueId;
// IDL_char *stmtLabel;
IDL_long *maxRowCnt;
IDL_long *maxRowLen;
IDL_short *sqlAsyncEnable;
IDL_long *queryTimeout;
dialogueId = (IDL_long *)(param[0] + (long)buffer);
maxRowCnt = (IDL_long *)(param[2] + (long)buffer);
maxRowLen = (IDL_long *)(param[3] + (long)buffer);
sqlAsyncEnable = (IDL_short *)(param[4] + (long)buffer);
queryTimeout = (IDL_long *)(param[5] + (long)buffer);
//
// swap
//
LONG_swap(dialogueId);
LONG_swap(maxRowCnt);
LONG_swap(maxRowLen);
SHORT_swap(sqlAsyncEnable);
LONG_swap(queryTimeout);
swapPointers(buffer, number_of_param);
}
void UPDATESRVRSTATE_swap(char* buffer)
{
short number_of_param = UpdateSrvrState_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
IDL_long *srvrType;
// IDL_char *srvrObjRef;
IDL_long *srvrState;
srvrType = (IDL_long *)(param[0] + (long)buffer);
srvrState = (IDL_long *)(param[2] + (long)buffer);
//
// swap srvrType
//
LONG_swap(srvrType);
//
// swap srvrState
//
LONG_swap(srvrState);
swapPointers(buffer, number_of_param);
}
void SQLEXECDIRECT_swap(char* buffer)
{
short number_of_param = ExecDirect_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
DIALOGUE_ID_def *dialogueId;
// IDL_char *stmtLabel;
// IDL_string cursorName;
// IDL_char *stmtExplainLabel;
IDL_short* stmtType;
IDL_short *sqlStmtType;
// IDL_string sqlString;
IDL_short *sqlAsyncEnable;
IDL_long *queryTimeout;
dialogueId = (IDL_long *)(param[0] + (long)buffer);
stmtType = (IDL_short *)(param[4] + (long)buffer);
sqlStmtType = (IDL_short *)(param[5] + (long)buffer);
sqlAsyncEnable = (IDL_short *)(param[7] + (long)buffer);
queryTimeout = (IDL_long *)(param[8] + (long)buffer);
//
// swap
//
LONG_swap(dialogueId);
SHORT_swap(stmtType);
SHORT_swap(sqlStmtType);
SHORT_swap(sqlAsyncEnable);
LONG_swap(queryTimeout);
swapPointers(buffer, number_of_param);
}
void SQLEXECUTECALL_swap(char* buffer)
{
short number_of_param = ExecuteCall_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
DIALOGUE_ID_def *dialogueId;
// IDL_char *stmtLabel;
// IDL_string cursorName;
IDL_short *sqlStmtType;
IDL_long *inputRowCnt;
SQLValueList_def *inputValueList;
IDL_short *sqlAsyncEnable;
IDL_long *queryTimeout;
dialogueId = (IDL_long *)(param[0] + (long)buffer);
sqlStmtType = (IDL_short *)(param[3] + (long)buffer);
inputRowCnt = (IDL_long *)(param[4] + (long)buffer);
inputValueList = (SQLValueList_def *)(param[5] + (long)buffer);
sqlAsyncEnable = (IDL_short *)(param[6] + (long)buffer);
queryTimeout = (IDL_long *)(param[7] + (long)buffer);
//
// swap
//
LONG_swap(dialogueId);
SHORT_swap(sqlStmtType);
LONG_swap(inputRowCnt);
SQL_VALUE_LIST_swap(buffer, inputValueList);
SHORT_swap(sqlAsyncEnable);
LONG_swap(queryTimeout);
swapPointers(buffer, number_of_param);
}
void STOPSRVR_swap(char* buffer)
{
short number_of_param = StopSrvr_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
DIALOGUE_ID_def *dialogueId;
IDL_long *srvrType;
// IDL_char *srvrObjRef;
IDL_long *StopType;
dialogueId = (IDL_long *)(param[0] + (long)buffer);
srvrType = (IDL_long *)(param[1] + (long)buffer);
StopType = (IDL_long *)(param[3] + (long)buffer);
//
// swap dialogueId
//
LONG_swap(dialogueId);
//
// swap srvrType
//
LONG_swap(srvrType);
//
// swap StopType
//
LONG_swap(StopType);
swapPointers(buffer, number_of_param);
}
void SQL_VALUE_LIST_swap(char* buffer, SQLValueList_def *valueList)
{
SQLValue_def *_buffer = valueList->_buffer;
IDL_unsigned_long _length = valueList->_length;
if (_buffer != NULL && _length != 0 )
{
SQLValue_def *pval;
ULONG_swap(&valueList->_length);
_buffer = (SQLValue_def *)((long)_buffer + (long)buffer);
for (unsigned int i=0; i<_length; i++)
{
SQL_DataValue_def *pdataValue;
pval = _buffer + i;
LONG_swap(&pval->dataType);
SHORT_swap(&pval->dataInd);
LONG_swap(&pval->dataCharset);
pdataValue = &pval->dataValue;
ULONG_swap(&pdataValue->_length);
}
}
}
void SQLEXECUTEROWSET_swap(char* buffer)
{
short number_of_param = ExecuteRowset_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
DIALOGUE_ID_def *dialogueId;
// IDL_char *stmtLabel;
// IDL_string cursorName;
IDL_short *sqlStmtType;
IDL_long *inputRowCnt;
SQL_DataValue_def *inputDataValue;
IDL_short *sqlAsyncEnable;
IDL_long *queryTimeout;
dialogueId = (IDL_long *)(param[0] + (long)buffer);
sqlStmtType = (IDL_short *)(param[3] + (long)buffer);
inputRowCnt = (IDL_long *)(param[4] + (long)buffer);
inputDataValue = (SQL_DataValue_def *)(param[5] + (long)buffer);
sqlAsyncEnable = (IDL_short *)(param[6] + (long)buffer);
queryTimeout = (IDL_long *)(param[7] + (long)buffer);
//
// swap
//
LONG_swap(dialogueId);
SHORT_swap(sqlStmtType);
LONG_swap(inputRowCnt);
ULONG_swap(&inputDataValue->_length);
SHORT_swap(sqlAsyncEnable);
LONG_swap(queryTimeout);
swapPointers(buffer, number_of_param);
}
void SQLPREPARE_swap(char* buffer)
{
short number_of_param = Prepare_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
DIALOGUE_ID_def *dialogueId;
// IDL_char *stmtLabel;
// IDL_char *stmtExplainLabel;
IDL_short *stmtType;
// IDL_string sqlString;
IDL_short *sqlAsyncEnable;
IDL_long *queryTimeout;
dialogueId = (IDL_long *)(param[0] + (long)buffer);
stmtType = (IDL_short *)(param[3] + (long)buffer);;
sqlAsyncEnable = (IDL_short *)(param[5] + (long)buffer);;
queryTimeout = (IDL_long *)(param[6] + (long)buffer);;
//
// swap
//
LONG_swap(dialogueId);
SHORT_swap(stmtType);
SHORT_swap(sqlAsyncEnable);
LONG_swap(queryTimeout);
swapPointers(buffer, number_of_param);
}
void SQLSETCONNECTATTR_swap(char* buffer)
{
short number_of_param = SetConnectionOption_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
DIALOGUE_ID_def *dialogueId;
IDL_short *connectionOption;
IDL_long *optionValueNum;
// IDL_string optionValueStr;
dialogueId = (IDL_long *)(param[0] + (long)buffer);
connectionOption = (IDL_short *)(param[1] + (long)buffer);;
optionValueNum = (IDL_long *)(param[2] + (long)buffer);;
//
// swap
//
LONG_swap(dialogueId);
SHORT_swap(connectionOption);
LONG_swap(optionValueNum);
swapPointers(buffer, number_of_param);
}
void SQL_ITEM_DESC_LIST_swap(char* buffer, SQLItemDescList_def *itemList)
{
SQLItemDesc_def *_buffer = itemList->_buffer;
IDL_unsigned_long _length = itemList->_length;
if (_buffer != NULL && _length != 0 )
{
SQLItemDesc_def *pitem;
ULONG_swap(&itemList->_length);
_buffer = (SQLItemDesc_def *)((long)_buffer + (long)buffer);
for (unsigned int i=0; i<_length; i++)
{
pitem = _buffer + i;
LONG_swap(&pitem->version);
LONG_swap(&pitem->dataType);
LONG_swap(&pitem->datetimeCode);
LONG_swap(&pitem->maxLen);
SHORT_swap(&pitem->precision);
SHORT_swap(&pitem->scale);
LONG_swap(&pitem->ODBCDataType);
SHORT_swap(&pitem->ODBCPrecision);
LONG_swap(&pitem->SQLCharset);
LONG_swap(&pitem->ODBCCharset);
LONG_swap(&pitem->intLeadPrec);
LONG_swap(&pitem->paramMode);
}
}
}
void HEADER_swap(HEADER* header)
{
SHORT_swap(&header->operation_id);
LONG_swap(&header->dialogueId);
ULONG_swap(&header->total_length);
ULONG_swap(&header->cmp_length);
LONG_swap((IDL_long*)&header->hdr_type);
ULONG_swap(&header->signature);
ULONG_swap(&header->version);
SHORT_swap(&header->error);
SHORT_swap(&header->error_detail);
}
void GETOBJREF_swap(char* buffer)
{
short number_of_param = GetObjRefHdl_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
CONNECTION_CONTEXT_def *inContext;
USER_DESC_def *userDesc;
IDL_long *srvrType;
IDL_short *retryCount;
inContext = (CONNECTION_CONTEXT_def *)(param[0] + (long)buffer);
userDesc = (USER_DESC_def *)(param[1] + (long)buffer);
srvrType = (IDL_long *)(param[2] + (long)buffer);
retryCount = (IDL_short *)(param[3] + (long)buffer);
//
// swap CONNECTION_CONTEXT_def
//
SHORT_swap(&inContext->accessMode);
SHORT_swap(&inContext->autoCommit);
SHORT_swap(&inContext->queryTimeoutSec);
SHORT_swap(&inContext->idleTimeoutSec);
SHORT_swap(&inContext->loginTimeoutSec);
SHORT_swap(&inContext->txnIsolationLevel);
SHORT_swap(&inContext->rowSetSize);
LONG_swap(&inContext->diagnosticFlag);
ULONG_swap(&inContext->processId);
ULONG_swap(&inContext->ctxACP);
ULONG_swap(&inContext->ctxDataLang);
ULONG_swap(&inContext->ctxErrorLang);
SHORT_swap(&inContext->ctxCtrlInferNCHAR);
VERSION_LIST_swap(buffer, &inContext->clientVersionList);
//
// swap userDesc
//
LONG_swap(&userDesc->userDescType);
ULONG_swap(&userDesc->userSid._length);
ULONG_swap(&userDesc->password._length);
//
// swap srvrType
//
LONG_swap(srvrType);
//
// swap retryCount
//
SHORT_swap(retryCount);
swapPointers(buffer, number_of_param);
}
void SQLCONNECT_swap(char* buffer)
{
short number_of_param = InitializeDialogue_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
USER_DESC_def *userDesc;
CONNECTION_CONTEXT_def *inContext;
DIALOGUE_ID_def *dialogueId;
userDesc = (USER_DESC_def *)(param[0] + (long)buffer);
inContext = (CONNECTION_CONTEXT_def *)(param[1] + (long)buffer);
dialogueId = (IDL_long *)(param[2] + (long)buffer);
//
// swap userDesc
//
LONG_swap(&userDesc->userDescType);
ULONG_swap(&userDesc->userSid._length);
ULONG_swap(&userDesc->password._length);
//
// swap CONNECTION_CONTEXT_def
//
SHORT_swap(&inContext->accessMode);
SHORT_swap(&inContext->autoCommit);
SHORT_swap(&inContext->queryTimeoutSec);
SHORT_swap(&inContext->idleTimeoutSec);
SHORT_swap(&inContext->loginTimeoutSec);
SHORT_swap(&inContext->txnIsolationLevel);
SHORT_swap(&inContext->rowSetSize);
LONG_swap(&inContext->diagnosticFlag);
ULONG_swap(&inContext->processId);
ULONG_swap(&inContext->ctxACP);
ULONG_swap(&inContext->ctxDataLang);
ULONG_swap(&inContext->ctxErrorLang);
SHORT_swap(&inContext->ctxCtrlInferNCHAR);
VERSION_LIST_swap(buffer, &inContext->clientVersionList);
//
// swap DIALOGUE_ID_def
//
LONG_swap(dialogueId);
swapPointers(buffer, number_of_param);
}
void SQL_WARNING_OR_ERROR_swap(BYTE *WarningOrError, IDL_long WarningOrErrorLengthCheck,char swap)
{
IDL_long msg_total_len = 0;
IDL_long numConditions = 0;
char sqlState[6];
IDL_long errorTextLen = 0;
unsigned char *curptr;
int i;
if (swap == SWAP_NO) return;
curptr = (unsigned char *)WarningOrError;
//swap numConditions and then pull it out, for indexing
LONG_swap((IDL_long*)(curptr+msg_total_len),swap);
numConditions = *(IDL_long*)(curptr+msg_total_len);
msg_total_len +=4;
if (numConditions > 0)
{
for (i = 0; i < numConditions; i++)
{
//rowId= *(IDL_long*)(curptr+msg_total_len);
LONG_swap((IDL_long*)(curptr+msg_total_len),swap);
msg_total_len +=4;
//sqlCode= *(IDL_long*)(curptr+msg_total_len);
LONG_swap((IDL_long*)(curptr+msg_total_len),swap);
msg_total_len +=4;
//swap errorTextLen then grab it
LONG_swap((IDL_long*)(curptr+msg_total_len),swap);
errorTextLen= *(IDL_long*)(curptr+msg_total_len);
msg_total_len +=4;
msg_total_len +=errorTextLen;
msg_total_len +=sizeof(sqlState);
}
}
}
void ERROR_DESC_LIST_swap(char* buffer, ERROR_DESC_LIST_def *errorList)
{
ERROR_DESC_def *_buffer = errorList->_buffer;
IDL_unsigned_long _length = errorList->_length;
if (_buffer != NULL && _length != 0 )
{
ERROR_DESC_def *perr;
ULONG_swap(&errorList->_length);
_buffer = (ERROR_DESC_def *)((long)_buffer + (long)buffer);
for (unsigned int i=0; i<_length; i++)
{
perr = _buffer + i;
LONG_swap(&perr->rowId);
LONG_swap(&perr->errorDiagnosticId);
LONG_swap(&perr->sqlcode);
LONG_swap(&perr->operationAbortId);
LONG_swap(&perr->errorCodeType);
}
}
}
void SQLDISCONNECT_swap(char* buffer)
{
short number_of_param = TerminateDialogue_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
DIALOGUE_ID_def *dialogueId;
dialogueId = (IDL_long *)(param[0] + (long)buffer);
//
// swap DIALOGUE_ID_def
//
LONG_swap(dialogueId);
swapPointers(buffer, number_of_param);
}
void SQLGETCATALOGS_swap(char* buffer)
{
short number_of_param = GetSQLCatalogs_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
DIALOGUE_ID_def *dialogueId;
// IDL_char *stmtLabel;
IDL_short *APIType;
// IDL_char *catalogNm;
// IDL_char *schemaNm;
// IDL_char *tableNm;
// IDL_char *tableTypeList;
// IDL_char *columnNm;
IDL_long *columnType;
IDL_long *rowIdScope;
IDL_long *nullable;
IDL_long *uniqueness;
IDL_long *accuracy;
IDL_short *sqlType;
IDL_unsigned_long *metadataId;
dialogueId = (IDL_long *)(param[0] + (long)buffer);
APIType = (IDL_short *)(param[2] + (long)buffer);
columnType = (IDL_long *)(param[8] + (long)buffer);
rowIdScope = (IDL_long *)(param[9] + (long)buffer);
nullable = (IDL_long *)(param[10] + (long)buffer);
uniqueness = (IDL_long *)(param[11] + (long)buffer);
accuracy = (IDL_long *)(param[12] + (long)buffer);
sqlType = (IDL_short *)(param[13] + (long)buffer);
metadataId = (IDL_unsigned_long *)(param[14] + (long)buffer);
//
// swap
//
LONG_swap(dialogueId);
SHORT_swap(APIType);
LONG_swap(columnType);
LONG_swap(rowIdScope);
LONG_swap(nullable);
LONG_swap(uniqueness);
LONG_swap(accuracy);
SHORT_swap(sqlType);
ULONG_swap(metadataId);
swapPointers(buffer, number_of_param);
}
void SQLENDTRAN_swap(char* buffer)
{
short number_of_param = EndTransaction_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
DIALOGUE_ID_def *dialogueId;
IDL_unsigned_short *transactionOpt;
dialogueId = (IDL_long *)(param[0] + (long)buffer);
transactionOpt = (IDL_unsigned_short *)(param[1] + (long)buffer);
//
// swap
//
LONG_swap(dialogueId);
USHORT_swap(transactionOpt);
swapPointers(buffer, number_of_param);
}
void SQLFREESTMT_swap(char* buffer)
{
short number_of_param = Close_in_params;
long* param = (long*)buffer;
long* pointers = (long*)buffer;
pointers += number_of_param;
DIALOGUE_ID_def *dialogueId;
// IDL_char *stmtLabel
IDL_unsigned_short *freeResourceOpt;
dialogueId = (IDL_long *)(param[0] + (long)buffer);
freeResourceOpt = (IDL_unsigned_short *)(param[2] + (long)buffer);
//
// swap
//
LONG_swap(dialogueId);
USHORT_swap(freeResourceOpt);
swapPointers(buffer, number_of_param);
}
extern "C" CEE_status
odbcas_ASSvc_GetObjRefHdl_(
/* In */ const CEE_handle_def *ph_
, /* In */ CEE_tag_def tag_
, /* In */ const CONNECTION_CONTEXT_def *inContext
, /* In */ const USER_DESC_def *userDesc
, /* In */ IDL_long srvrType
, /* In */ IDL_short retryCount
, /* Out */ odbcas_ASSvc_GetObjRefHdl_exc_ *exception_
, /* Out */ char *srvrObjRef
, /* Out */ DIALOGUE_ID_def *dialogueId
, /* Out */ char *dataSource
, /* Out */ USER_SID_def *userSid
, /* Out */ VERSION_LIST_def *versionList
, /* Out */ IDL_long *isoMapping
, /* Out */ IDL_long *srvrNodeId
, /* Out */ IDL_long *srvrProcessId
, /* Out */ IDL_long_long *timestamp
)
{
CEE_status retcode;
bool sts;
IDL_long wlength,rlength;
IDL_char* wbuffer, *rbuffer;
IDL_char* curptr;
IDL_long msg_total_length = 0;
IDL_long exceptionLength = 0;
IDL_long datasourceLength = 0;
IDL_long srvrObjRefLength = 0;
IDL_long userSidLength = 0;
IDL_long clusternameLength = 0;
VERSION_def version[4];
VERSION_def* versionPtr = &version[0];
char srvrHostName[100] = {0};
IDL_long srvrHostNameLength = 0;
char srvrProcessName[100] = {0};
IDL_long srvrProcessNameLength = 0;
char srvrIpAddress[100] = {0};
IDL_long srvrIpAddressLength = 0;
IDL_long srvrPort = 0;
SRVR_CALL_CONTEXT *srvrCallContext = (SRVR_CALL_CONTEXT *)tag_;
CConnect *pConnection = (CConnect *)srvrCallContext->sqlHandle;
pConnection->m_asTCPIPSystem->odbcAPI = AS_API_GETOBJREF;
pConnection->m_asTCPIPSystem->dialogueId = srvrCallContext->dialogueId;
pConnection->m_asTCPIPSystem->dwTimeout = srvrCallContext->u.connectParams.loginTimeout;
//
// do marshaling of input parameters
//
retcode = odbcas_ASSvc_GetObjRefHdl_param_pst_(
pConnection->m_asTCPIPSystem
, wbuffer
, wlength
, inContext
, userDesc
, srvrType
, retryCount);
if (retcode != CEE_SUCCESS)
return retcode;
sts = OpenIO (pConnection->m_asTCPIPSystem,pConnection->getAsObjRef());
if (sts == false)
return MAP_AS_ERRORS((long)pConnection->m_asTCPIPSystem);
sts = DoIO (pConnection->m_asTCPIPSystem, wbuffer, wlength, rbuffer, rlength,pConnection);
if (sts == false)
return MAP_AS_ERRORS((long)pConnection->m_asTCPIPSystem);
CloseIO (pConnection->m_asTCPIPSystem);
//
// process output parameters
//
char swap = pConnection->m_asTCPIPSystem->swap();
curptr = rbuffer;
//
// copy odbcas_ASSvc_GetObjRefHdl_exc_ *exception_
//
exception_->exception_nr = *(IDL_long *)(curptr + msg_total_length);
msg_total_length += sizeof(exception_->exception_nr);
LONG_swap(&exception_->exception_nr,swap);
exception_->exception_detail = *(IDL_long *)(curptr + msg_total_length);
msg_total_length += sizeof(exception_->exception_detail);
LONG_swap(&exception_->exception_detail,swap);
exceptionLength = *(IDL_long *)(curptr + msg_total_length);
msg_total_length += sizeof(exceptionLength);
LONG_swap(&exceptionLength,swap);
if(exceptionLength > 0)
{
exception_->u.ASParamError.ErrorText = (IDL_char*)(curptr+msg_total_length);
msg_total_length += exceptionLength;
return CEE_SUCCESS; // no point in continuing
}
//
// copy DIALOGUE_ID_def dialogueId
//
*dialogueId = *(IDL_long *) (curptr + msg_total_length);
msg_total_length += sizeof(*dialogueId);
LONG_swap(dialogueId,swap);
//
// copy IDL_char *dataSource
//
datasourceLength = *(IDL_long *)(curptr + msg_total_length);
msg_total_length += sizeof(datasourceLength);
LONG_swap(&datasourceLength,swap);
if (datasourceLength != 0)
{
memcpy(dataSource, curptr + msg_total_length, datasourceLength);
msg_total_length += datasourceLength;
}
// copy userSidLength
userSid->_length = *(IDL_unsigned_long *)(curptr+msg_total_length);
msg_total_length += sizeof(userSid->_length);
ULONG_swap(&userSid->_length,swap);
// copy userSid
if (userSid->_length != 0)
{
userSid->_buffer = (unsigned char *)(IDL_char*)(curptr+msg_total_length);
msg_total_length += userSid->_length+1;
}
// copy VERSION_LIST_def *versionList
versionList->_length = *(IDL_unsigned_long *)(curptr + msg_total_length);
msg_total_length += sizeof(versionList->_length);
ULONG_swap(&versionList->_length,swap);
// Get the versionPtr
versionList->_buffer = (VERSION_def *)new char[versionList->_length*sizeof(VERSION_def)];
versionPtr = versionList->_buffer;
for (int i = 0; i < versionList->_length; i++)
{
// copy componentId
versionPtr->componentId = *(IDL_short *)(curptr + msg_total_length);
msg_total_length += sizeof(versionPtr->componentId);
SHORT_swap(&versionPtr->componentId,swap);
// copy majorVersion
versionPtr->majorVersion = *(IDL_short *)(curptr + msg_total_length);
msg_total_length += sizeof(versionPtr->majorVersion);
SHORT_swap(&versionPtr->majorVersion,swap);
// copy minorVersion
versionPtr->minorVersion = *(IDL_short *)(curptr + msg_total_length);
msg_total_length += sizeof(versionPtr->minorVersion);
SHORT_swap(&versionPtr->minorVersion,swap);
// copy buildId
versionPtr->buildId = *(IDL_unsigned_long *)(curptr + msg_total_length);
msg_total_length += sizeof(versionPtr->buildId);
ULONG_swap(&versionPtr->buildId,swap);
// Get the next versionlist values
versionPtr++;
}
//Check whether connected to an R2.3 server
if (versionList->_buffer->buildId & CHARSET)
{
//
// copy IDL_long isoMapping
//
*isoMapping = *(IDL_long *) (curptr + msg_total_length);
msg_total_length += sizeof(*isoMapping);
LONG_swap(isoMapping,swap);
}
else
*isoMapping = NON_CHARSET_SYSTEM ; //Connected to an R2.2 system.
//
// copy IDL_char *srvrHostName
//
srvrHostNameLength = *(IDL_long *)(curptr + msg_total_length);
msg_total_length += sizeof(srvrHostNameLength);
LONG_swap(&srvrHostNameLength,swap);
if (srvrHostNameLength != 0)
{
memcpy(srvrHostName, curptr + msg_total_length, srvrHostNameLength);
msg_total_length += srvrHostNameLength;
}
//
// copy IDL_long srvrNodeId
//
*srvrNodeId = *(IDL_long *) (curptr + msg_total_length);
msg_total_length += sizeof(*srvrNodeId);
LONG_swap(srvrNodeId,swap);
//
// copy IDL_long srvrProcessId
//
*srvrProcessId = *(IDL_long *) (curptr + msg_total_length);
msg_total_length += sizeof(*srvrProcessId);
LONG_swap(srvrProcessId,swap);
//
// copy IDL_char *srvrProcessName
//
srvrProcessNameLength = *(IDL_long *)(curptr + msg_total_length);
msg_total_length += sizeof(srvrProcessNameLength);
LONG_swap(&srvrProcessNameLength,swap);
if (srvrProcessNameLength != 0)
{
memcpy(srvrProcessName, curptr + msg_total_length, srvrProcessNameLength);
msg_total_length += srvrProcessNameLength;
}
//
// copy IDL_char *srvrIpAddress
//
srvrIpAddressLength = *(IDL_long *)(curptr + msg_total_length);
msg_total_length += sizeof(srvrIpAddressLength);
LONG_swap(&srvrIpAddressLength,swap);
if (srvrProcessNameLength != 0)
{
memcpy(srvrIpAddress, curptr + msg_total_length, srvrIpAddressLength);
msg_total_length += srvrIpAddressLength;
}
//
// copy IDL_long srvrPort
//
srvrPort = *(IDL_long *) (curptr + msg_total_length);
msg_total_length += sizeof(srvrPort);
LONG_swap(&srvrPort,swap);
sprintf(srvrObjRef,"TCP:%s:%d.%s,%s/%d:ODBC", srvrHostName, *srvrNodeId, srvrProcessName, srvrIpAddress, srvrPort);
//Check whether connected to server with password security support
if (versionList->_buffer->buildId & PASSWORD_SECURITY)
{
//
// copy IDL_long_long timestamp
//
*timestamp = *(IDL_long_long *) (curptr + msg_total_length);
msg_total_length += sizeof(*timestamp);
LONGLONG_swap(timestamp,swap);
//
// copy clustername
//
clusternameLength = *(IDL_long *)(curptr + msg_total_length);
msg_total_length += sizeof(clusternameLength);
LONG_swap(&clusternameLength,swap);
if (clusternameLength != 0)
{
memcpy(pConnection->m_ClusterName, curptr + msg_total_length, clusternameLength);
msg_total_length += clusternameLength;
}
}
return CEE_SUCCESS;
}
/*
* Synchronous object call for
* operation 'odbcas_ASSvc_StopSrvr'
*/
extern "C" void
odbcas_ASSvc_StopSrvr(
/* In */ const CEE_handle_def *ph_
, /* Out */ struct odbcas_ASSvc_StopSrvr_exc_ *exception_
, /* In */ DIALOGUE_ID_def dialogueId
, /* In */ IDL_long srvrType
, /* In */ const IDL_char *srvrObjRef
, /* In */ IDL_long StopType
)
{
CEE_status retcode;
bool sts;
IDL_char *curptr;
IDL_long msg_total_len = 0;
IDL_long wlength, rlength;
IDL_char *wbuffer, *rbuffer;
SRVR_CALL_CONTEXT *srvrCallContext = (SRVR_CALL_CONTEXT *)ph_;
CConnect *pConnection = (CConnect *)srvrCallContext->sqlHandle;
pConnection->m_asTCPIPSystem->odbcAPI = AS_API_STOPSRVR;
pConnection->m_asTCPIPSystem->dialogueId = srvrCallContext->dialogueId;
pConnection->m_asTCPIPSystem->dwTimeout = srvrCallContext->u.connectParams.loginTimeout;
//
// do marshaling of input parameters
//
retcode = odbcas_ASSvc_StopSrvr_param_pst_(
pConnection->m_asTCPIPSystem
, wbuffer
, wlength
, dialogueId
, srvrType
, srvrObjRef
, StopType);
if (retcode != CEE_SUCCESS)
return;
sts = OpenIO (pConnection->m_asTCPIPSystem,pConnection->getAsObjRef());
if (sts == false)
return;
sts = DoIO (pConnection->m_asTCPIPSystem, wbuffer, wlength, rbuffer, rlength,pConnection);
if (sts == false)
return;
CloseIO (pConnection->m_asTCPIPSystem);
//
// process output parameters
//
char swap = pConnection->m_asTCPIPSystem->swap();
msg_total_len = 0;
curptr = rbuffer;
//
// exception_
//
IDL_long ExceptionLength;
//
// exception_ ->exception_nr
//
exception_->exception_nr = *(IDL_long*)(curptr+msg_total_len);
msg_total_len += sizeof(exception_->exception_nr);
LONG_swap(&exception_->exception_nr,swap);
//
// exception_ ->exception_detail
//
exception_->exception_detail = *(IDL_long*)(curptr+msg_total_len);
msg_total_len += sizeof(exception_->exception_detail);
LONG_swap(&exception_->exception_detail,swap);
ExceptionLength = *(IDL_long*)(curptr+msg_total_len);
msg_total_len += sizeof(ExceptionLength);
LONG_swap(&ExceptionLength,swap);
if(ExceptionLength > 0)
{
exception_->u.ASParamError.ErrorText = (IDL_char*)(curptr+msg_total_len);
msg_total_len += ExceptionLength;
}
return;
}
